@im-nobsidian/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,935 @@
+import { z } from 'zod';
+import { Client } from '@notionhq/client';
+import { PageObjectResponse, BlockObjectResponse, PartialBlockObjectResponse } from '@notionhq/client/build/src/api-endpoints.js';
+
+declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    notion: z.ZodObject<{
+        token: z.ZodString;
+        rootPageId: z.ZodString;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        parentMode: z.ZodDefault<z.ZodEnum<["page", "database"]>>;
+        databaseId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        rootPageId: string;
+        parentMode: "page" | "database";
+        workspaceId?: string | undefined;
+        databaseId?: string | undefined;
+    }, {
+        token: string;
+        rootPageId: string;
+        workspaceId?: string | undefined;
+        parentMode?: "page" | "database" | undefined;
+        databaseId?: string | undefined;
+    }>;
+    sync: z.ZodObject<{
+        direction: z.ZodDefault<z.ZodEnum<["push", "pull", "both"]>>;
+        conflictStrategy: z.ZodDefault<z.ZodEnum<["local-first", "remote-first", "manual", "duplicate"]>>;
+        autoSync: z.ZodDefault<z.ZodBoolean>;
+        autoSyncInterval: z.ZodDefault<z.ZodNumber>;
+        deleteSync: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        direction: "push" | "pull" | "both";
+        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        autoSync: boolean;
+        autoSyncInterval: number;
+        deleteSync: boolean;
+    }, {
+        direction?: "push" | "pull" | "both" | undefined;
+        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        autoSync?: boolean | undefined;
+        autoSyncInterval?: number | undefined;
+        deleteSync?: boolean | undefined;
+    }>;
+    paths: z.ZodObject<{
+        include: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        attachments: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        include: string[];
+        exclude: string[];
+        attachments: string;
+    }, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        attachments?: string | undefined;
+    }>;
+    conversion: z.ZodObject<{
+        preferMarkdownApi: z.ZodDefault<z.ZodBoolean>;
+        preserveMarkers: z.ZodDefault<z.ZodBoolean>;
+        frontmatterMapping: z.ZodDefault<z.ZodBoolean>;
+        imageDownload: z.ZodDefault<z.ZodEnum<["immediate", "lazy", "skip"]>>;
+    }, "strip", z.ZodTypeAny, {
+        preferMarkdownApi: boolean;
+        preserveMarkers: boolean;
+        frontmatterMapping: boolean;
+        imageDownload: "immediate" | "lazy" | "skip";
+    }, {
+        preferMarkdownApi?: boolean | undefined;
+        preserveMarkers?: boolean | undefined;
+        frontmatterMapping?: boolean | undefined;
+        imageDownload?: "immediate" | "lazy" | "skip" | undefined;
+    }>;
+    advanced: z.ZodObject<{
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        concurrency: number;
+        maxRetries: number;
+        timeoutMs: number;
+        batchSize: number;
+    }, {
+        concurrency?: number | undefined;
+        maxRetries?: number | undefined;
+        timeoutMs?: number | undefined;
+        batchSize?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    notion: {
+        token: string;
+        rootPageId: string;
+        parentMode: "page" | "database";
+        workspaceId?: string | undefined;
+        databaseId?: string | undefined;
+    };
+    sync: {
+        direction: "push" | "pull" | "both";
+        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        autoSync: boolean;
+        autoSyncInterval: number;
+        deleteSync: boolean;
+    };
+    paths: {
+        include: string[];
+        exclude: string[];
+        attachments: string;
+    };
+    conversion: {
+        preferMarkdownApi: boolean;
+        preserveMarkers: boolean;
+        frontmatterMapping: boolean;
+        imageDownload: "immediate" | "lazy" | "skip";
+    };
+    advanced: {
+        concurrency: number;
+        maxRetries: number;
+        timeoutMs: number;
+        batchSize: number;
+    };
+}, {
+    version: 1;
+    notion: {
+        token: string;
+        rootPageId: string;
+        workspaceId?: string | undefined;
+        parentMode?: "page" | "database" | undefined;
+        databaseId?: string | undefined;
+    };
+    sync: {
+        direction?: "push" | "pull" | "both" | undefined;
+        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        autoSync?: boolean | undefined;
+        autoSyncInterval?: number | undefined;
+        deleteSync?: boolean | undefined;
+    };
+    paths: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        attachments?: string | undefined;
+    };
+    conversion: {
+        preferMarkdownApi?: boolean | undefined;
+        preserveMarkers?: boolean | undefined;
+        frontmatterMapping?: boolean | undefined;
+        imageDownload?: "immediate" | "lazy" | "skip" | undefined;
+    };
+    advanced: {
+        concurrency?: number | undefined;
+        maxRetries?: number | undefined;
+        timeoutMs?: number | undefined;
+        batchSize?: number | undefined;
+    };
+}>;
+type Config = z.infer<typeof ConfigSchema>;
+declare const DEFAULT_CONFIG: Config;
+
+type SyncDirection = "push" | "pull" | "both";
+type FileType = "file" | "folder-note" | "folder-only" | "db-row";
+type SyncStatus = "synced" | "pending" | "conflict" | "error";
+type OperationType = "create" | "update" | "delete" | "move";
+type ConflictStrategy = "local-first" | "remote-first" | "manual" | "duplicate";
+interface SyncRecord {
+    readonly id: string;
+    readonly obsidianPath: string;
+    readonly notionPageId: string | null;
+    readonly notionParentId: string | null;
+    readonly contentHash: string;
+    readonly notionLastEdited: string | null;
+    readonly localLastModified: string;
+    readonly syncDirection: SyncDirection;
+    readonly fileType: FileType;
+    readonly status: SyncStatus;
+    readonly baseSnapshot: Buffer | null;
+    readonly version: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface LocalChange {
+    readonly path: string;
+    readonly type: "created" | "modified" | "deleted" | "moved";
+    readonly currentHash: string;
+    readonly previousHash: string | null;
+    readonly movedFrom?: string;
+}
+interface RemoteChange {
+    readonly pageId: string;
+    readonly type: "created" | "modified" | "deleted" | "moved";
+    readonly lastEdited: string;
+    readonly previousEdited: string | null;
+    readonly movedFromParent?: string;
+}
+interface Conflict {
+    readonly syncRecord: SyncRecord;
+    readonly localChange: LocalChange;
+    readonly remoteChange: RemoteChange;
+    readonly baseContent: string | null;
+    readonly localContent: string;
+    readonly remoteContent: string;
+}
+type ProgressCallback = (current: number, total: number, path: string) => void;
+interface PushOptions {
+    readonly paths?: string[];
+    readonly force?: boolean;
+    readonly dryRun?: boolean;
+    readonly onProgress?: ProgressCallback;
+}
+interface PullOptions {
+    readonly paths?: string[];
+    readonly force?: boolean;
+    readonly dryRun?: boolean;
+    readonly onProgress?: ProgressCallback;
+}
+interface SyncOptions {
+    readonly paths?: string[];
+    readonly force?: boolean;
+    readonly dryRun?: boolean;
+    readonly onProgress?: ProgressCallback;
+}
+interface PushResult {
+    readonly created: number;
+    readonly updated: number;
+    readonly deleted: number;
+    readonly failed: FailedOperation[];
+    readonly duration: number;
+}
+interface PullResult {
+    readonly created: number;
+    readonly updated: number;
+    readonly deleted: number;
+    readonly conflicts: Conflict[];
+    readonly writtenPaths: string[];
+    readonly failed: FailedOperation[];
+    readonly duration: number;
+}
+interface SyncResult {
+    readonly push: PushResult;
+    readonly pull: PullResult;
+    readonly conflicts: Conflict[];
+    readonly duration: number;
+}
+interface StatusResult {
+    readonly localChanges: LocalChange[];
+    readonly remoteChanges: RemoteChange[];
+    readonly conflicts: Conflict[];
+    readonly conflictRecords: SyncRecord[];
+    readonly pendingOperations: number;
+    readonly lastSyncAt: string | null;
+}
+interface FailedOperation {
+    readonly path: string;
+    readonly operation: OperationType;
+    readonly error: string;
+}
+
+type ConversionPath = "markdown-api" | "block-api";
+interface ProcessorInput {
+    readonly content: string;
+    readonly metadata: ProcessorMetadata;
+    readonly context: ConversionContext;
+}
+interface ProcessorOutput {
+    readonly content: string;
+    readonly metadata: ProcessorMetadata;
+}
+interface ProcessorMetadata {
+    readonly properties?: Record<string, unknown>;
+    readonly preserveMarkers?: PreserveMarker[];
+    readonly images?: ImageReference[];
+    readonly [key: string]: unknown;
+}
+interface ConversionContext {
+    readonly direction: "push" | "pull";
+    readonly path: ConversionPath;
+    readonly filePath: string;
+    readonly parentMode?: "page" | "database";
+}
+interface Processor {
+    readonly name: string;
+    readonly order: number;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+interface ConversionResult {
+    readonly content: string;
+    readonly properties: Record<string, unknown>;
+    readonly images: ImageReference[];
+    readonly preserveMarkers: PreserveMarker[];
+}
+interface PreserveMarker {
+    readonly type: string;
+    readonly params: Record<string, string>;
+    readonly startIndex: number;
+    readonly endIndex?: number;
+}
+interface ImageReference {
+    readonly url: string;
+    readonly localPath?: string;
+    readonly hash?: string;
+    readonly isExternal: boolean;
+}
+interface WikilinkEntry {
+    readonly obsidianPath: string;
+    readonly notionPageId: string;
+    readonly title: string;
+    readonly aliases: readonly string[];
+}
+
+declare class ConfigManager {
+    private readonly vaultRoot;
+    private config;
+    constructor(vaultRoot: string);
+    get configDir(): string;
+    get configPath(): string;
+    get dbPath(): string;
+    load(): Promise<Config>;
+    save(config: Config): Promise<void>;
+    init(params: {
+        token: string;
+        rootPageId: string;
+    }): Promise<Config>;
+    getConfig(): Config;
+    private ensureGitignore;
+    isInitialized(): Promise<boolean>;
+}
+
+declare class StateDB {
+    private readonly db;
+    private constructor();
+    static open(dbPath: string): StateDB;
+    private migrate;
+    private getSchemaVersion;
+    close(): void;
+    getByPath(path: string): SyncRecord | null;
+    getByNotionId(pageId: string): SyncRecord | null;
+    getByStatus(status: SyncStatus): SyncRecord[];
+    getAll(): SyncRecord[];
+    upsert(record: UpsertSyncRecord): SyncRecord;
+    updateStatus(id: string, status: SyncStatus): void;
+    updateHash(id: string, hash: string, snapshot?: Buffer | null): void;
+    delete(id: string): void;
+    resolveWikilink(text: string): WikilinkEntry | null;
+    resolvePageId(pageId: string): WikilinkEntry | null;
+    upsertWikilink(entry: WikilinkEntry): void;
+    getMeta(key: string): string | null;
+    setMeta(key: string, value: string): void;
+    storePreserveMarkers(path: string, markers: PreserveMarker[]): void;
+    getPreserveMarkers(path: string): PreserveMarker[];
+    transaction<T>(fn: () => T): T;
+    private mapRow;
+    private mapWikilinkRow;
+}
+interface UpsertSyncRecord {
+    readonly obsidianPath: string;
+    readonly notionPageId?: string | null;
+    readonly notionParentId?: string | null;
+    readonly contentHash: string;
+    readonly notionLastEdited?: string | null;
+    readonly localLastModified: string;
+    readonly syncDirection: SyncRecord["syncDirection"];
+    readonly fileType: SyncRecord["fileType"];
+    readonly status: SyncRecord["status"];
+    readonly baseSnapshot?: Buffer | null;
+}
+
+interface NotionClientOptions {
+    readonly token: string;
+    readonly concurrency?: number;
+    readonly timeoutMs?: number;
+}
+declare class NotionClient {
+    private readonly client;
+    private readonly sema;
+    private readonly propertyMapper;
+    constructor(options: NotionClientOptions);
+    getInternalClient(): Client;
+    getPage(pageId: string): Promise<PageObjectResponse>;
+    createPage(params: {
+        parentId: string;
+        parentType: "page" | "database";
+        title: string;
+        properties?: Record<string, unknown>;
+        children?: BlockObjectResponse[];
+    }): Promise<PageObjectResponse>;
+    updatePageProperties(pageId: string, properties: Record<string, unknown>): Promise<PageObjectResponse>;
+    getDatabaseSchema(databaseId: string): Promise<Record<string, {
+        id: string;
+        type: string;
+    }>>;
+    queryDatabase(databaseId: string, options?: {
+        startCursor?: string;
+        pageSize?: number;
+    }): Promise<{
+        results: PageObjectResponse[];
+        nextCursor: string | null;
+    }>;
+    archivePage(pageId: string): Promise<void>;
+    listChildren(blockId: string, options?: {
+        startCursor?: string;
+        pageSize?: number;
+    }): Promise<{
+        results: (BlockObjectResponse | PartialBlockObjectResponse)[];
+        nextCursor: string | null;
+    }>;
+    fetchAllChildren(blockId: string): Promise<BlockObjectResponse[]>;
+    appendChildren(blockId: string, children: unknown[]): Promise<void>;
+    deleteBlock(blockId: string): Promise<void>;
+    search(params: {
+        query?: string;
+        filter?: {
+            property: "object";
+            value: "page" | "database";
+        };
+        startCursor?: string;
+        pageSize?: number;
+    }): Promise<{
+        results: PageObjectResponse[];
+        nextCursor: string | null;
+    }>;
+    getChildPages(parentId: string): Promise<PageObjectResponse[]>;
+    getChildPagesRecursive(parentId: string): Promise<PageObjectResponse[]>;
+    extractTitle(page: PageObjectResponse): string;
+    extractProperties(page: PageObjectResponse): Record<string, unknown>;
+    private withRateLimit;
+    private executeWithRetry;
+}
+
+interface RichTextSegment {
+    content: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+    color?: string;
+    link?: string;
+}
+interface NotionRichText {
+    type: "text";
+    text: {
+        content: string;
+        link?: {
+            url: string;
+        } | null;
+    };
+    annotations: {
+        bold: boolean;
+        italic: boolean;
+        underline: boolean;
+        strikethrough: boolean;
+        code: boolean;
+        color: string;
+    };
+}
+interface NotionEquationRichText {
+    type: "equation";
+    equation: {
+        expression: string;
+    };
+}
+interface NotionMentionRichText {
+    type: "mention";
+    mention: {
+        type: "page";
+        page: {
+            id: string;
+        };
+    } | {
+        type: "date";
+        date: {
+            start: string;
+            end?: string;
+        };
+    } | {
+        type: "user";
+        user: {
+            id: string;
+        };
+    } | {
+        type: "database";
+        database: {
+            id: string;
+        };
+    };
+}
+type RichTextItem = NotionRichText | NotionEquationRichText | NotionMentionRichText;
+interface NotionBlock {
+    object?: "block";
+    type: string;
+    [key: string]: unknown;
+}
+declare class NotionBlockBuilder {
+    static richText(content: string, options?: Partial<RichTextSegment>): NotionRichText[];
+    static richTextArray(segments: RichTextSegment[]): NotionRichText[];
+    static richTextEquation(expression: string): NotionEquationRichText[];
+    static richTextMentionPage(pageId: string): NotionMentionRichText[];
+    static richTextMentionDate(start: string, end?: string): NotionMentionRichText[];
+    static paragraph(richText: RichTextItem[], color?: string): NotionBlock;
+    static heading(level: 1 | 2 | 3, richText: RichTextItem[], options?: {
+        color?: string;
+        isToggleable?: boolean;
+        children?: NotionBlock[];
+    }): NotionBlock;
+    static callout(richText: RichTextItem[], icon?: string, options?: {
+        color?: string;
+        children?: NotionBlock[];
+    }): NotionBlock;
+    static toggle(richText: RichTextItem[], children?: NotionBlock[], color?: string): NotionBlock;
+    static bulletedListItem(richText: RichTextItem[], children?: NotionBlock[], color?: string): NotionBlock;
+    static numberedListItem(richText: RichTextItem[], children?: NotionBlock[], color?: string): NotionBlock;
+    static toDo(richText: RichTextItem[], checked?: boolean, color?: string): NotionBlock;
+    static quote(richText: RichTextItem[], children?: NotionBlock[], color?: string): NotionBlock;
+    static divider(): NotionBlock;
+    static code(code: string, language?: string, caption?: string): NotionBlock;
+    static equationBlock(expression: string): NotionBlock;
+    static image(url: string, caption?: string): NotionBlock;
+    static bookmark(url: string, caption?: string): NotionBlock;
+    static video(url: string, caption?: string): NotionBlock;
+    static audio(url: string, caption?: string): NotionBlock;
+    static fileBlock(url: string, name?: string, caption?: string): NotionBlock;
+    static pdf(url: string, caption?: string): NotionBlock;
+    static embed(url: string, caption?: string): NotionBlock;
+    static tableOfContents(color?: string): NotionBlock;
+    static breadcrumb(): NotionBlock;
+    static columnList(columns: NotionBlock[][]): NotionBlock;
+    static syncedBlockOriginal(children: NotionBlock[]): NotionBlock;
+    static syncedBlockDuplicate(originalBlockId: string): NotionBlock;
+    static linkToPage(pageId: string): NotionBlock;
+    static table(rows: string[][], hasColumnHeader?: boolean, hasRowHeader?: boolean): NotionBlock;
+}
+
+type NotionPropertyValue = Record<string, unknown>;
+declare class PropertyMapper {
+    private schema;
+    loadSchema(properties: Record<string, {
+        id: string;
+        type: string;
+    }>): void;
+    toNotionProperties(frontmatter: Record<string, unknown>, title: string): Record<string, NotionPropertyValue>;
+    fromNotionProperties(notionProps: Record<string, unknown>): Record<string, unknown>;
+    private convertBySchema;
+    private inferAndConvert;
+    private extractValue;
+}
+
+interface FileInfo {
+    readonly path: string;
+    readonly content: string;
+    readonly mtime: string;
+}
+declare class ChangeDetector {
+    private readonly stateDb;
+    constructor(stateDb: StateDB);
+    detectLocalChanges(currentFiles: FileInfo[]): LocalChange[];
+    private detectMoves;
+}
+
+interface VaultFS {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    writeBinary(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    moveFile(from: string, to: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    ensureFolder(path: string): Promise<void>;
+    listMarkdownFiles(): Promise<FileInfo[]>;
+}
+
+declare class SyncOrchestrator {
+    private readonly config;
+    private readonly stateDb;
+    private readonly notionClient;
+    private readonly vaultFs;
+    private readonly changeDetector;
+    private readonly pipeline;
+    private readonly blockConverter;
+    private readonly imageHandler;
+    private readonly propertyMapper;
+    private dbSchemaLoaded;
+    constructor(config: Config, stateDb: StateDB, notionClient: NotionClient, vaultFs: VaultFS);
+    push(options?: PushOptions): Promise<PushResult>;
+    pull(options?: PullOptions): Promise<PullResult>;
+    sync(options?: SyncOptions): Promise<SyncResult>;
+    status(): Promise<StatusResult>;
+    private buildConflictsFromRecords;
+    private get isDatabaseMode();
+    private ensureDbSchema;
+    private pushCreate;
+    private pushUpdate;
+    private pushDelete;
+    private detectRemoteChanges;
+    private pullCreate;
+    private pullUpdate;
+    private pullDelete;
+    private ensureFolderPage;
+    private resolveNotionParent;
+    private isFolderNote;
+    private resolveParentPath;
+    private extractParentId;
+}
+
+interface PathFilterConfig {
+    readonly include?: string[];
+    readonly exclude?: string[];
+}
+declare class NodeVaultFS implements VaultFS {
+    private readonly rootPath;
+    private readonly includePatterns;
+    private readonly excludePatterns;
+    constructor(rootPath: string, pathConfig?: PathFilterConfig);
+    private loadImNobsidianIgnore;
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    writeBinary(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    moveFile(from: string, to: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    ensureFolder(path: string): Promise<void>;
+    listMarkdownFiles(): Promise<FileInfo[]>;
+    private matchesPattern;
+    private isExcluded;
+    private walkDir;
+}
+
+interface ImageDownloadResult {
+    readonly originalUrl: string;
+    readonly localPath: string;
+    readonly hash: string;
+    readonly size: number;
+}
+declare class ImageHandler {
+    private readonly vaultFs;
+    private readonly attachmentFolder;
+    constructor(vaultFs: VaultFS, attachmentFolder?: string);
+    downloadImage(url: string, pageTitle: string): Promise<ImageDownloadResult>;
+    downloadAllImages(markdown: string, pageTitle: string): Promise<{
+        content: string;
+        downloads: ImageDownloadResult[];
+    }>;
+    private isNotionImageUrl;
+    private guessExtension;
+}
+
+declare class ConversionPipeline {
+    private readonly preProcessors;
+    private readonly postProcessors;
+    registerPreProcessor(processor: Processor): void;
+    registerPostProcessor(processor: Processor): void;
+    selectPath(content: string): ConversionPath;
+    convertToNotion(markdown: string, context: ConversionContext): ConversionResult;
+    convertToMarkdown(content: string, context: ConversionContext, metadata?: ProcessorMetadata): string;
+}
+
+declare class BlockConverter {
+    private n2m;
+    private client;
+    initNotionToMd(client: Client): void;
+    private registerCustomTransformers;
+    private registerToggleTransformer;
+    private registerToggleHeadingTransformers;
+    private registerColumnTransformer;
+    private registerSyncedBlockTransformer;
+    private registerBookmarkTransformer;
+    private registerVideoTransformer;
+    private registerAudioTransformer;
+    private registerFileTransformer;
+    private registerChildPageTransformer;
+    private registerChildDatabaseTransformer;
+    private registerLinkToPageTransformer;
+    private registerTocTransformer;
+    private registerBreadcrumbTransformer;
+    private registerLinkPreviewTransformer;
+    private registerCalloutTransformer;
+    markdownToNotionBlocks(markdown: string): unknown[];
+    private toggleContents;
+    private columnContents;
+    private toggleCounter;
+    private columnCounter;
+    private preProcessMarkdown;
+    private replaceDividers;
+    private extractToggleBlocks;
+    private extractColumnBlocks;
+    private postProcessBlocks;
+    private convertTogglePlaceholder;
+    private convertColumnPlaceholder;
+    private convertDividerPlaceholder;
+    private convertImageToVideoOrEmbed;
+    private convertQuoteToCallout;
+    notionBlocksToMarkdown(pageId: string): Promise<string>;
+}
+
+declare class FrontmatterExtractor implements Processor {
+    readonly name = "FrontmatterExtractor";
+    readonly order = 10;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class WikilinkResolver implements Processor {
+    readonly name = "WikilinkResolver";
+    readonly order = 20;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class CalloutTransformer implements Processor {
+    readonly name = "CalloutTransformer";
+    readonly order = 30;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class InlineDBParser implements Processor {
+    readonly name = "InlineDBParser";
+    readonly order = 40;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class MathNormalizer implements Processor {
+    readonly name = "MathNormalizer";
+    readonly order = 50;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class EmbedResolver implements Processor {
+    readonly name = "EmbedResolver";
+    readonly order = 60;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class PreserveMarkerCollector implements Processor {
+    readonly name = "PreserveMarkerCollector";
+    readonly order = 70;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class UnsupportedBlockStripper implements Processor {
+    readonly name = "UnsupportedBlockStripper";
+    readonly order = 5;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class PropertiesTableInjector implements Processor {
+    readonly name = "PropertiesTableInjector";
+    readonly order = 15;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class HtmlAnnotationStripper implements Processor {
+    readonly name = "HtmlAnnotationStripper";
+    readonly order = 5;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class MentionToWikilink implements Processor {
+    readonly name = "MentionToWikilink";
+    readonly order = 10;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class CalloutRestorer implements Processor {
+    readonly name = "CalloutRestorer";
+    readonly order = 20;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class ColorAnnotator implements Processor {
+    readonly name = "ColorAnnotator";
+    readonly order = 30;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class FrontmatterGenerator implements Processor {
+    readonly name = "FrontmatterGenerator";
+    readonly order = 90;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class PreserveMarkerInjector implements Processor {
+    readonly name = "PreserveMarkerInjector";
+    readonly order = 100;
+    process(input: ProcessorInput): ProcessorOutput;
+    private formatMarker;
+}
+
+declare class LocalImageRestorer implements Processor {
+    readonly name = "LocalImageRestorer";
+    readonly order = 15;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+declare class PropertiesTableRestorer implements Processor {
+    readonly name = "PropertiesTableRestorer";
+    readonly order = 5;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
+interface MergeResult {
+    readonly success: boolean;
+    readonly merged: string;
+    readonly conflicts: MergeConflictRegion[];
+}
+interface MergeConflictRegion {
+    readonly localLines: string[];
+    readonly remoteLines: string[];
+}
+declare function threeWayMerge(base: string, local: string, remote: string): MergeResult;
+
+type ResolutionChoice = "local" | "remote" | "merge" | "duplicate";
+interface ResolutionResult {
+    readonly path: string;
+    readonly choice: ResolutionChoice;
+    readonly success: boolean;
+    readonly mergeHadConflicts?: boolean;
+}
+declare class ConflictResolver {
+    private readonly stateDb;
+    private readonly vaultFs;
+    constructor(stateDb: StateDB, vaultFs: VaultFS);
+    resolve(conflict: Conflict, choice: ResolutionChoice): Promise<ResolutionResult>;
+    resolveByStrategy(conflict: Conflict, strategy: ConflictStrategy): Promise<ResolutionResult>;
+    resolveAll(conflicts: Conflict[], strategy: ConflictStrategy): Promise<ResolutionResult[]>;
+    private resolveLocal;
+    private resolveRemote;
+    private resolveMerge;
+    private resolveDuplicate;
+    generateDiff(conflict: Conflict): string;
+}
+
+interface NotionPageNode {
+    readonly id: string;
+    readonly title: string;
+    readonly hasContent: boolean;
+    readonly hasChildren: boolean;
+    readonly isDatabase: boolean;
+    readonly parentId: string | null;
+    readonly children: NotionPageNode[];
+}
+type MappingType = "file" | "folder-note" | "folder-only" | "database-folder";
+interface MappingResult {
+    readonly type: MappingType;
+    readonly obsidianPath: string;
+    readonly folderPath?: string;
+    readonly notePath?: string;
+    readonly schemaPath?: string;
+}
+declare class TreeMapper {
+    mapNotionToObsidian(root: NotionPageNode, basePath?: string): MappingResult[];
+    private mapRecursive;
+    mapObsidianToNotion(entries: FileSystemEntry[], parentPageId: string): PageCreationPlan[];
+    private planRecursive;
+    private findFolderNote;
+    determineFileType(page: {
+        hasContent: boolean;
+        hasChildren: boolean;
+        isDatabase: boolean;
+    }): MappingType;
+}
+interface FileSystemEntry {
+    readonly name: string;
+    readonly path: string;
+    readonly isDirectory: boolean;
+    readonly children: FileSystemEntry[];
+}
+interface PageCreationPlan {
+    readonly type: "page-with-children" | "empty-page-with-children" | "leaf-page";
+    readonly title: string;
+    readonly parentPageId: string;
+    readonly contentSource?: string;
+    readonly hasContent: boolean;
+}
+
+type WatchEvent = "add" | "change" | "unlink";
+interface WatchCallback {
+    (event: WatchEvent, path: string): void;
+}
+declare class FileWatcher {
+    private readonly rootPath;
+    private readonly callback;
+    private watcher;
+    constructor(rootPath: string, callback: WatchCallback);
+    start(): void;
+    stop(): Promise<void>;
+}
+
+interface WatchSyncOptions {
+    readonly debounceMs?: number;
+    readonly syncDirection?: "push" | "pull" | "both";
+    readonly onSyncStart?: () => void;
+    readonly onSyncComplete?: (result: SyncResult) => void;
+    readonly onSyncError?: (error: Error) => void;
+    readonly onFileChange?: (event: WatchEvent, path: string) => void;
+}
+declare class WatchSyncService {
+    private readonly rootPath;
+    private readonly orchestrator;
+    private readonly debounceMs;
+    private readonly options;
+    private watcher;
+    private debounceTimer;
+    private pendingChanges;
+    private syncing;
+    private syncQueued;
+    private running;
+    constructor(rootPath: string, orchestrator: SyncOrchestrator, options?: WatchSyncOptions);
+    start(): void;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isSyncing(): boolean;
+    getPendingCount(): number;
+    private handleFileChange;
+    private scheduleSync;
+    private clearDebounce;
+    private executeSync;
+}
+
+declare function computeHash(content: string): string;
+declare function computeBufferHash(buffer: Buffer): string;
+
+declare function generateId(): string;
+declare function normalizeNotionId(id: string): string;
+declare function notionIdsEqual(a: string, b: string): boolean;
+
+declare function sanitizeFileName(name: string): string;
+
+interface Logger {
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+}
+declare function setLogger(logger: Logger): void;
+declare function getLogger(): Logger;
+
+declare function createDefaultPipeline(): ConversionPipeline;
+
+export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, type Config, ConfigManager, ConfigSchema, type Conflict, ConflictResolver, type ConflictStrategy, type ConversionContext, type ConversionPath, ConversionPipeline, type ConversionResult, DEFAULT_CONFIG, EmbedResolver, type FailedOperation, type FileInfo, type FileSystemEntry, type FileType, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, type ImageDownloadResult, ImageHandler, type ImageReference, InlineDBParser, type LocalChange, LocalImageRestorer, type Logger, type MappingResult, type MappingType, MathNormalizer, MentionToWikilink, type MergeConflictRegion, type MergeResult, NodeVaultFS, type NotionBlock, NotionBlockBuilder, NotionClient, type NotionClientOptions, type NotionPageNode, type NotionRichText, type RichTextItem as NotionRichTextItem, type OperationType, type PageCreationPlan, type PathFilterConfig, type PreserveMarker, PreserveMarkerCollector, PreserveMarkerInjector, type Processor, type ProcessorInput, type ProcessorMetadata, type ProcessorOutput, type ProgressCallback, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, type PullOptions, type PullResult, type PushOptions, type PushResult, type RemoteChange, type ResolutionChoice, type ResolutionResult, type RichTextSegment, StateDB, type StatusResult, type SyncDirection, type SyncOptions, SyncOrchestrator, type SyncRecord, type SyncResult, type SyncStatus, TreeMapper, UnsupportedBlockStripper, type UpsertSyncRecord, type VaultFS, type WatchSyncOptions, WatchSyncService, type WikilinkEntry, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, generateId, getLogger, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, threeWayMerge };