/**
 * Programmatic migration API (SPEC_F §F.9).
 *
 * Usage:
 *   import { createMigration } from 'resplite/migration';
 *
 *   const m = createMigration({
 *     from: 'redis://127.0.0.1:6379',
 *     to:   './data.db',
 *     runId: 'my-migration-1',
 *   });
 *
 *   const info   = await m.preflight();
 *   await m.bulk({ onProgress: console.log });
 *   const status = m.status();
 *   await m.applyDirty({ onProgress: console.log });
 *   const result = await m.verify();
 *   await m.close();
 */
import { runPreflight, readKeyspaceEvents, setKeyspaceEvents } from './preflight.ts';
import type { PreflightResult, SetKeyspaceEventsResult } from './preflight.ts';
import { runBulkImport } from './bulk.ts';
import type { BulkProgress } from './bulk.ts';
import { runApplyDirty } from './apply-dirty.ts';
import type { DirtyProgress } from './apply-dirty.ts';
import { runVerify } from './verify.ts';
import type { VerifyResult } from './verify.ts';
import { runMigrateSearch } from './migrate-search.ts';
import type { MigrateSearchOptions, MigrateSearchResult } from './migrate-search.ts';
import type { DirtyCounts, MigrationRun } from './registry.ts';
import type { DirtyTrackerProgress } from './tracker.ts';
export interface MigrationOptions {
    /** Source Redis URL. Default `'redis://127.0.0.1:6379'`. */
    from?: string;
    /** Destination SQLite DB path. */
    to: string;
    /** Unique run identifier (required for bulk/status/applyDirty). */
    runId?: string;
    /** PRAGMA preset. Default `'default'`. */
    pragmaTemplate?: string;
    /** Default 1000. */
    scanCount?: number;
    /** Max requests/s (0 = unlimited). Default 0. */
    maxRps?: number;
    /** Concurrent imports during bulk/apply-dirty migration. Default 1. */
    concurrency?: number;
    /** Optional total-keys estimate for ETA/progress in onProgress. Default 0. */
    estimatedTotalKeys?: number;
    /** Default 200. */
    batchKeys?: number;
    /** 64 MB default. */
    batchBytes?: number;
    /** Redis CONFIG command name. Override if renamed for security. Default `'CONFIG'`. */
    configCommand?: string;
}
export interface EnableKeyspaceNotificationsOptions {
    /** Flags to apply. Defaults to `'KEA'` (keyevent + keyspace + all event types). */
    value?: string;
    /** If true (default), merges flags into the existing value instead of overwriting. */
    merge?: boolean;
}
export interface ControllerDirtyTrackerOptions {
    pragmaTemplate?: string;
    onProgress?: (progress: DirtyTrackerProgress) => void | Promise<void>;
}
export interface ControllerBulkOptions {
    /** Start or continue automatically. Default true. */
    resume?: boolean;
    /** Concurrent key imports. Defaults to the createMigration option. */
    concurrency?: number;
    /** Used to compute ETA/progress fields in onProgress. */
    estimatedTotalKeys?: number;
    onProgress?: (run: BulkProgress) => void;
}
export interface ControllerApplyDirtyOptions {
    batchKeys?: number;
    maxRps?: number;
    concurrency?: number;
    progressIntervalMs?: number;
    onProgress?: (run: DirtyProgress) => void | Promise<void>;
}
export interface ControllerVerifyOptions {
    samplePct?: number;
    maxSample?: number;
}
export type ControllerMigrateSearchOptions = Omit<MigrateSearchOptions, 'pragmaTemplate'>;
export interface MigrationStatus {
    run: MigrationRun;
    dirty: DirtyCounts;
}
/** Migration controller returned by `createMigration`. */
export interface MigrationController {
    preflight(): Promise<PreflightResult>;
    enableKeyspaceNotifications(opts?: EnableKeyspaceNotificationsOptions): Promise<SetKeyspaceEventsResult>;
    startDirtyTracker(opts?: ControllerDirtyTrackerOptions): Promise<{
        running: true;
    }>;
    stopDirtyTracker(): Promise<{
        running: false;
    }>;
    bulk(opts?: ControllerBulkOptions): Promise<MigrationRun | undefined>;
    status(): MigrationStatus | null;
    applyDirty(opts?: ControllerApplyDirtyOptions): Promise<MigrationRun | undefined>;
    verify(opts?: ControllerVerifyOptions): Promise<VerifyResult>;
    migrateSearch(opts?: ControllerMigrateSearchOptions): Promise<MigrateSearchResult>;
    close(): Promise<void>;
}
/**
 * Create a migration controller bound to a source Redis and destination DB.
 */
export declare function createMigration({ from, to, runId, pragmaTemplate, scanCount, maxRps, concurrency, estimatedTotalKeys, batchKeys, batchBytes, configCommand, }?: MigrationOptions): MigrationController;
export { runPreflight, readKeyspaceEvents, setKeyspaceEvents, runBulkImport, runApplyDirty, runVerify, runMigrateSearch };
export { startDirtyTracker } from './tracker.ts';
export { getRun, getDirtyCounts, createRun, setRunStatus, logError } from './registry.ts';
export type { KeyspaceEventsReadResult, SetKeyspaceEventsOptions, SetKeyspaceEventsResult, PreflightOptions, PreflightResult, } from './preflight.ts';
export type { BulkImportOptions, BulkProgress } from './bulk.ts';
export type { ApplyDirtyOptions, DirtyProgress } from './apply-dirty.ts';
export type { VerifyOptions, VerifyMismatch, VerifyResult } from './verify.ts';
export type { MigrateSearchOptions, MigrateSearchResult, IndexResult } from './migrate-search.ts';
export type { DirtyTracker, DirtyTrackerOptions, DirtyTrackerProgress } from './tracker.ts';
export type { MigrationRun, RunStatus, DirtyKeyState, DirtyCounts, MigrationErrorStage, CreateRunOptions, CreateRunResult, } from './registry.ts';
export type { MigrationRedisClient, MigrationScanReply } from './redis-client.ts';