import FilenSDK, { type PauseSignal } from "@filen/sdk";
import { type SyncPair, type SyncMode } from "../types";
import { LocalFileSystem, LocalTree, type LocalTreeError } from "./filesystems/local";
import { RemoteFileSystem, RemoteTree } from "./filesystems/remote";
import Deltas from "./deltas";
import Tasks, { type TaskError } from "./tasks";
import State from "./state";
import Ignorer from "../ignorer";
import type SyncWorker from "..";
import Lock from "./lock";
import { type SyncEnvironment } from "./environment";
/**
 * Sync
 *
 * @export
 * @class Sync
 * @typedef {Sync}
 */
export declare class Sync {
    readonly sdk: FilenSDK;
    readonly environment: SyncEnvironment;
    readonly syncPair: SyncPair;
    private isInitialized;
    readonly localFileSystem: LocalFileSystem;
    readonly remoteFileSystem: RemoteFileSystem;
    readonly deltas: Deltas;
    previousLocalTree: LocalTree;
    previousRemoteTree: RemoteTree;
    localFileHashes: Record<string, string>;
    readonly tasks: Tasks;
    readonly state: State;
    readonly dbPath: string;
    readonly abortControllers: Record<string, AbortController>;
    readonly pauseSignals: Record<string, PauseSignal>;
    readonly ignorer: Ignorer;
    paused: boolean;
    mode: SyncMode;
    excludeDotFiles: boolean;
    readonly worker: SyncWorker;
    removed: boolean;
    readonly lock: Lock;
    taskErrors: TaskError[];
    localTrashDisabled: boolean;
    localTreeErrors: LocalTreeError[];
    cleaningLocalTrash: boolean;
    cleanupLocalTrashInterval: ReturnType<typeof setInterval> | undefined;
    isPreviousSavedTreeStateEmpty: boolean;
    requireConfirmationOnLargeDeletion: boolean;
    deletionConfirmationResult: "delete" | "restart" | "waiting";
    /**
     * Creates an instance of Sync.
     *
     * @constructor
     * @public
     * @param {{ syncPair: SyncPair; worker: SyncWorker }} param0
     * @param {SyncPair} param0.syncPair
     * @param {SyncWorker} param0.worker
     */
    constructor({ syncPair, worker }: {
        syncPair: SyncPair;
        worker: SyncWorker;
    });
    smokeTest(): Promise<void>;
    cleanupLocalTrash(): void;
    cleanupLocalTrashOnce(): Promise<void>;
    initialize(): Promise<void>;
    cleanup({ deleteLocalDbFiles }: {
        deleteLocalDbFiles?: boolean;
    }): Promise<void>;
    deleteLocalSyncDbFiles(): Promise<void>;
    private run;
    /**
     * Run exactly one synchronization cycle without scheduling the next one.
     *
     * This is the body of a single pass: error/pause gating, lock acquisition,
     * tree diffing, delta processing, task execution and state persistence. It
     * never throws (failures are caught and reported as a "cycleError" message)
     * and never reschedules — {@link run} owns the self-scheduling loop. Exposed
     * so a single cycle can be driven deterministically.
     *
     * @public
     * @async
     * @returns {Promise<void>}
     */
    runCycle(): Promise<void>;
}
export default Sync;