Struct ImportEngine 

pub struct ImportEngine<'a> { /* private fields */ }

Import workflow engine.

Implementations

impl<'a> ImportEngine<'a>

pub async fn notes( &self, notes: &[Note], on_duplicate: OnDuplicate, ) -> Result<ImportReport>

Import notes with duplicate handling.

Validates notes, checks for duplicates, and imports in batches.

Arguments

• notes - Notes to import
• on_duplicate - Strategy for handling duplicates

Example

let engine = Engine::new();

let notes = vec![
    NoteBuilder::new("Default", "Basic")
        .field("Front", "Q1")
        .field("Back", "A1")
        .build(),
];

let report = engine.import().notes(&notes, OnDuplicate::Skip).await?;

pub async fn validate(&self, notes: &[Note]) -> Result<Vec<ValidationResult>>

Validate notes before import without actually importing.

Returns detailed validation results for each note.

pub async fn smart_add( &self, note: &Note, options: SmartAddOptions, ) -> Result<SmartAddResult>

Smart add a single note with duplicate checking and tag suggestions.

Combines validation, duplicate detection, and tag suggestions into a single atomic operation.

Arguments

• note - Note to add
• options - Options controlling duplicate handling and tag suggestions

Example

let engine = Engine::new();

let note = NoteBuilder::new("Japanese", "Basic")
    .field("Front", "hello")
    .field("Back", "world")
    .build();

let result = engine.import().smart_add(&note, SmartAddOptions::default()).await?;

match result.status {
    ankit_engine::import::SmartAddStatus::Added => {
        println!("Added note: {:?}", result.note_id);
    }
    ankit_engine::import::SmartAddStatus::RejectedDuplicate { existing_id } => {
        println!("Duplicate of note {}", existing_id);
    }
    _ => {}
}

if !result.suggested_tags.is_empty() {
    println!("Suggested tags: {:?}", result.suggested_tags);
}

Trait Implementations

impl<'a> Debug for ImportEngine<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.