@vireocodedev/sqlite

export type CreateDatabaseOwnerStoreConfig = {
    key: string;
    getStorage: () => KeyValueStorage;
};

export type CreateHydrationControllerConfig<TLockOwner = unknown> = {
    getContributors: () => HydrationContributor[];
    entityStateClient: {
        list: () => Promise<SqliteHydrationEntityStateRecord[]>;
        upsert: (state: SqliteHydrationEntityStateRecord) => Promise<void>;
    };
    requests: Pick<HydrationRequestQueue, "consume" | "hasPending" | "rejectPending" | "settle" | "reject">;
    runHydrationExclusive: (operation: (signal: AbortSignal, lockOwner: TLockOwner) => Promise<void>) => Promise<void>;
    runEntityExclusive: (entityKey: string, operation: () => Promise<void>, lockOwner: TLockOwner) => Promise<void>;
    fetchRemoteVersions: (entityKeys: string[], signal: AbortSignal) => Promise<{
        versions: RemoteHydrationVersion[];
    }>;
    events: HydrationControllerEvents;
    remoteVersionsTimeoutMs: number;
    entityTimeoutMs: (entityKey: string) => number;
    retryBaseMs: number;
    retryMaxMs: number;
    retryExponentLimit?: number;
    elapsedNow?: () => number;
    timestampNow?: () => number;
    schedule?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
    cancelScheduled?: (handle: ReturnType<typeof setTimeout>) => void;
    isCancellationError?: (error: unknown) => boolean;
    debug?: (message: string, details?: HydrationLogDetails) => void;
    warn?: (message: string, details?: HydrationLogDetails) => void;
    error?: (message: string, details?: HydrationLogDetails) => void;
};

export type CreateHydrationGateConfig = {
    now?: () => number;
};

export type CreateHydrationRequestQueueConfig = {
    onRequestQueued?: () => void;
    createUnexpectedError?: () => Error;
};

export type CreateHydrationStatusConfig = {
    now?: () => number;
};

export type CreateLocalReflectionQueueConfig = {
    runEntityExclusive: (entityKey: string, operation: () => Promise<void>) => Promise<void>;
    onError?: (entityKey: string, error: unknown) => void;
    onPendingCountChange?: (pendingCount: number) => void;
};

export type CreateOfflineDataLifecycleConfig = {
    readOwner: () => string | null;
    persistOwner: (owner: string) => void;
    resolveDatabaseFileName: (owner: string, legacyOwner: string | null) => string;
    abortHydration: (reason: string) => void;
    awaitHydrationIdle: () => Promise<void>;
    awaitLocalReflectionIdle: () => Promise<void>;
    awaitQueueFlushIdle: () => Promise<void>;
    resetHydrationGate: () => void;
    resetHydrationStatus: () => void;
    resetQueueStatus: () => void;
    resetRuntime: () => void;
    clearInMemoryStores: () => void;
    deleteDatabaseFiles: (fileName?: string) => Promise<void>;
    hydrationAbortReason?: string;
};

export type CreateOfflineQueueCaptureConfig<TRequest extends OfflineQueueCaptureRequest> = {
    resolveUrl: (request: TRequest) => string;
    createCommandId: () => string;
    now: () => number;
    enqueue: (command: OfflineSyncCommand) => Promise<void>;
    markEnqueued: () => void;
    refreshStatus: () => Promise<void>;
};

export type CreateOfflineQueueClientConfig = {
    runtime: OfflineQueueClientRuntime;
    transport: Pick<SqliteTransport, "sendWorkerRequest">;
};

export type CreateOfflineQueueStatusConfig = {
    readStatusCounts: () => Promise<OfflineQueueStatusCounts>;
    onReadError?: (error: unknown) => void;
};

export type CreateOpfsDatabaseFilesConfig = {
    legacyFileName: string;
    mappingKeyPrefix: string;
    getStorage: () => KeyValueStorage;
    getDirectory: () => Promise<FileSystemDirectoryHandle> | null;
    createScopedFileName: (encodedOwner: string) => string;
    lockRetryDelayMs?: number;
    wait?: (delayMs: number) => Promise<void>;
};

export type CreateSqlConsoleClientConfig = {
    runtime: {
        shouldUseInMemoryFallback: () => boolean;
    };
    transport: Pick<SqliteTransport, "sendWorkerRequest">;
    requestTypes?: {
        executeScript: string;
        executePagedQuery: string;
    };
    now?: () => number;
    log?: (message: string, ...details: unknown[]) => void;
    createUnavailableError?: (operation: "script" | "paged-query") => Error;
};

export type CreateSqliteOperationCoordinatorConfig = {
    lockName: string;
    getLockManager?: () => ExclusiveLockManager | null;
    createAbortReason?: (reason: string) => unknown;
};

export type CreateSqliteTransportConfig = {
    runtime: SqliteTransportRuntime;
    createUnavailableError?: (requestType: string) => Error;
};

export type CreateSqliteWorkerRuntimeConfigInput = {
    dbFile: string;
    migrations: SqliteMigration[];
    entityBundles: SqliteWorkerEntityBundleConfig[];
    debug?: boolean;
    extraRequestHandlers?: SqliteRequestHandlers[];
};

export type DatabaseOwnerStore = {
    read: () => string | null;
    persist: (owner: string) => void;
    clear: () => void;
};

export type ExclusiveLockManager = {
    request: <T>(name: string, options: {
        mode: "exclusive";
    }, callback: () => Promise<T>) => Promise<T>;
};

export declare const HYDRATION_ENTITY_STATE_SQLITE_REQUEST_HANDLERS: {
    listHydrationEntityStates: (db: SqliteDatabase) => SqliteHydrationEntityStateRecord[];
    upsertHydrationEntityState: (db: SqliteDatabase, request: import('..').WorkerRequest) => null;
};

export type HydrationContributor = {
    key: string;
    hydrate: (signal: AbortSignal) => Promise<{
        rowCount: number;
    }>;
};

export type HydrationContributorRegistry = {
    register: (contributors: HydrationContributor[]) => void;
    list: () => HydrationContributor[];
};

export type HydrationController = {
    run: (context?: HydrationRunContext) => Promise<void>;
    requestRetry: () => void;
    reset: (pendingRequestReason: string) => void;
    cancelScheduledRetry: () => void;
    dispose: () => void;
    isRunning: () => boolean;
};

export type HydrationControllerEvents = {
    registerEntities: (keys: string[]) => void;
    markRunning: (running: boolean) => void;
    markEntityRunning: (key: string) => void;
    markEntitySuccess: (key: string, rowCount: number) => void;
    markEntityError: (key: string, message: string) => void;
    startGate: () => void;
    resetGate: () => void;
    finishGate: () => void;
    markDataReady: () => void;
    setErrorMessage: (message: string | null) => void;
};

export type HydrationEntityClient = {
    list: () => Promise<SqliteHydrationEntityStateRecord[]>;
    upsert: (state: SqliteHydrationEntityStateRecord) => Promise<void>;
    dispose: () => void;
};

export type HydrationEntityClientRuntime = {
    shouldUseInMemoryFallback: () => boolean;
    registerInMemoryStore: (store: InMemorySqliteStore) => () => void;
};

export type HydrationEntityStateSqliteOperationMap = {
    listHydrationEntityStates: {
        request: Record<string, never>;
        response: SqliteHydrationEntityStateRecord[];
    };
    upsertHydrationEntityState: {
        request: {
            state: SqliteHydrationEntityStateRecord;
        };
        response: null;
    };
};

export type HydrationEntityStatus = {
    key: string;
    state: "idle" | "running" | "success" | "error";
    lastAttemptAt: number | null;
    lastSuccessAt: number | null;
    rowCount: number | null;
    errorMessage: string | null;
};

export type HydrationGate = {
    getSnapshot: () => HydrationGateSnapshot;
    subscribe: (listener: (snapshot: HydrationGateSnapshot) => void) => () => void;
    setErrorMessage: (message: string | null) => void;
    requestRetry: () => void;
    reset: () => void;
    start: () => void;
    finish: () => void;
    markDataReady: () => void;
};

export type HydrationGatePhase = "idle" | "running" | "finished";

export type HydrationGateSnapshot = {
    phase: HydrationGatePhase;
    startedAt: number | null;
    dataReady: boolean;
    errorMessage: string | null;
    retryRequestTick: number;
};

export type HydrationLogDetails = Record<string, unknown>;

export type HydrationRequest = {
    keys: Set<string>;
    resolve: () => void;
    reject: (error: Error) => void;
};

export type HydrationRequestBatch = {
    requests: HydrationRequest[];
    forcedKeys: Set<string>;
};

export type HydrationRequestQueue = {
    request: (keys: string[]) => Promise<void>;
    consume: () => HydrationRequestBatch;
    hasPending: () => boolean;
    rejectPending: (reason: string) => void;
    settle: (batch: HydrationRequestBatch, failedKeys: ReadonlySet<string>) => void;
    reject: (batch: HydrationRequestBatch, error: unknown) => void;
};

export type HydrationRunContext = {
    heartbeatEnabled?: boolean;
    heartbeatConnected?: boolean;
};

export type HydrationStatus = {
    getSnapshot: () => HydrationStatusSnapshot;
    subscribe: (listener: (snapshot: HydrationStatusSnapshot) => void) => () => void;
    registerEntities: (keys: string[]) => void;
    markRunning: (running: boolean) => void;
    markEntityRunning: (key: string) => void;
    markEntitySuccess: (key: string, rowCount: number) => void;
    markEntityError: (key: string, errorMessage: string) => void;
    reset: () => void;
};

export type HydrationStatusSnapshot = {
    entities: HydrationEntityStatus[];
    running: boolean;
};

export type InMemorySqliteStore = {
    clear: () => void;
};

export type KeyValueStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;

export type LocalReflectionQueue = {
    enqueue: (entityKey: string, operation: () => Promise<void>) => void;
    awaitIdle: () => Promise<void>;
    getPendingCount: () => number;
};

export type ManagedSqliteRuntime = {
    registerInMemoryStore: (store: InMemorySqliteStore) => () => void;
    clearInMemoryStores: () => void;
    shouldUseInMemoryFallback: () => boolean;
    send: <T extends WorkerResponseResult>(payload: WorkerRequestInput) => Promise<T>;
    ensureInitialized: () => Promise<void>;
    warmup: () => Promise<void>;
    reset: () => void;
    dispose: () => void;
};

export type ManagedSqliteRuntimeConfig = {
    workerFactory: () => Worker;
    shouldUseInMemoryFallback?: () => boolean;
    debug?: boolean;
    bootLogPrefix?: string;
    now?: () => number;
};

export declare const OFFLINE_QUEUE_PENDING = "PENDING";

export declare const OFFLINE_QUEUE_PERMANENTLY_FAILED = "PERMANENTLY_FAILED";

export declare const OFFLINE_QUEUE_STATE_SQLITE_REQUEST_HANDLERS: {
    enqueue: (db: SqliteDatabase, request: import('..').WorkerRequest) => null;
    getPendingBatch: (db: SqliteDatabase, request: import('..').WorkerRequest) => OfflineQueuedCommand[];
    deleteCommands: (db: SqliteDatabase, request: import('..').WorkerRequest) => null;
    getQueueSize: (db: SqliteDatabase) => number;
    getStatusCounts: (db: SqliteDatabase) => OfflineQueueStatusCounts;
    markCommandsRetryable: (db: SqliteDatabase, request: import('..').WorkerRequest) => null;
    markCommandsPermanentlyFailed: (db: SqliteDatabase, request: import('..').WorkerRequest) => null;
};

export type OfflineDataLifecycle = {
    release: (options?: OfflineDataLifecycleOptions) => Promise<void>;
    purge: (options?: OfflineDataLifecycleOptions) => Promise<void>;
    ensureOwnedBy: (owner: string) => Promise<boolean>;
};

export type OfflineDataLifecycleOptions = {
    onPhase?: (phase: OfflineDataLifecyclePhase) => void;
};

export type OfflineDataLifecyclePhase = "hydration" | "queue" | "storage";

export type OfflineQueueCaptureRequest = {
    method?: string;
    body?: unknown;
    headers?: Record<string, unknown>;
};

export type OfflineQueueClient = {
    enqueue: (command: OfflineSyncCommand) => Promise<void>;
    getBatch: (batchSize: number) => Promise<OfflineQueuedCommand[]>;
    delete: (commandIds: string[]) => Promise<void>;
    markRetryable: (commandIds: string[], lastError: string | null, maxRetryCount: number) => Promise<void>;
    markPermanentlyFailed: (commandIds: string[], lastError: string | null) => Promise<void>;
    getSize: () => Promise<number>;
    getStatusCounts: () => Promise<OfflineQueueStatusCounts>;
    dispose: () => void;
};

export type OfflineQueueClientRuntime = {
    shouldUseInMemoryFallback: () => boolean;
    registerInMemoryStore: (store: InMemorySqliteStore) => () => void;
};

export type OfflineQueueStatus = {
    getSnapshot: () => OfflineQueueStatusSnapshot;
    subscribe: (listener: OfflineQueueStatusListener) => () => void;
    markEnqueued: () => void;
    refresh: () => Promise<void>;
    resetCounts: () => void;
};

export type OfflineQueueStatusCounts = {
    pending: number;
    permanentlyFailed: number;
};

export type OfflineQueueStatusListener = (snapshot: OfflineQueueStatusSnapshot) => void;

export type OfflineQueueStatusSnapshot = OfflineQueueStatusCounts & {
    enqueueTick: number;
};

export type OfflineQueuedCommand = OfflineSyncCommandRecord & {
    status: OfflineQueuedCommandStatus;
    retryCount: number;
    lastError: string | null;
};

export type OfflineQueuedCommandStatus = typeof OFFLINE_QUEUE_PENDING | typeof OFFLINE_QUEUE_PERMANENTLY_FAILED;

export type OfflineSyncBatchResponse = {
    accepted: number;
    failed: number;
    results: OfflineSyncCommandResult[];
};

export type OfflineSyncCommandDto = Pick<OfflineSyncCommand, "commandId" | "method" | "url" | "body" | "headers">;

export type OfflineSyncCommandRecord = {
    commandId: string;
    method: string;
    url: string;
    body: unknown | null;
    headers: Record<string, string>;
    createdAt: number;
};

export type OfflineSyncCommandResult = {
    commandId: string;
    success: boolean;
    status: number;
    error: string | null;
    reason?: OfflineSyncResultReason | null;
};

export type OfflineSyncReplayDependencies = {
    getBatch: (batchSize: number) => Promise<OfflineSyncCommand[]>;
    sendBatch: (commands: OfflineSyncCommandDto[]) => Promise<OfflineSyncBatchResponse>;
    cleanupSuccessfulCommands: (commands: OfflineSyncCommand[]) => Promise<void>;
    deleteSuccessful: (commandIds: string[]) => Promise<void>;
    markPermanentlyFailed: (commandIds: string[], lastError: string | null) => Promise<void>;
    markRetryable: (commandIds: string[], lastError: string | null, maxAttempts: number) => Promise<void>;
    refreshStatus: () => Promise<void>;
};

export type OfflineSyncResultReason = "APPLIED" | "ALREADY_APPLIED" | "RETRYABLE" | "REJECTED" | "RETRY_LIMIT_EXCEEDED";

export type OpfsDatabaseFiles = {
    getFileName: (owner: string, legacyOwner: string | null) => string;
    deleteFiles: (fileName?: string) => Promise<void>;
};

export type RemoteHydrationVersion = {
    entity: string;
    revision: number;
};

export declare const SQL_CONSOLE_SQLITE_REQUEST_HANDLERS: {
    executeSqlScript: (db: SqliteDatabase, request: import('..').WorkerRequest) => SqlExecutionResult;
    executePagedQuery: (db: SqliteDatabase, request: import('..').WorkerRequest) => SqlPagedQueryResult;
};

export type SqlConsoleClient = {
    executeScript: (script: string) => Promise<SqlExecutionResult>;
    executePagedQuery: (request: SqlPagedQueryRequest) => Promise<SqlPagedQueryResult>;
};

export type SqlConsoleSqliteOperationMap = {
    executeSqlScript: {
        request: {
            script: string;
        };
        response: SqlExecutionResult;
    };
    executePagedQuery: {
        request: SqlPagedQueryRequest;
        response: SqlPagedQueryResult;
    };
};

export type SqlExecutionResult = {
    statements: SqlExecutionStatementResult[];
};

export type SqlExecutionStatementResult = {
    statement: string;
    columns: string[];
    rows: unknown[][];
    rowsAffected: number;
};

export type SqlPagedQueryRequest = {
    selectSql: string;
    fromSql: string;
    whereSql: string;
    orderBySql: string;
    limit: number | null;
    offset: number | null;
    includeTotalCount?: boolean;
    clientSentAtMs?: number;
};

export type SqlPagedQueryResult = {
    columns: string[];
    rows: unknown[][];
    totalElements: number | null;
    queueWaitMs?: number;
    workerExecMs?: number;
};

export type SqliteDatabase = {
    exec: (sql: string) => unknown;
    prepare: (sql: string) => SqliteStatement;
};

export type SqliteEntityBundle<TFields extends SqliteEntityFields, TOperationNames extends {
    replace: string;
    upsert: string;
    list: string;
    delete: string;
}, TRequestKeys extends {
    replace: string;
    upsert: string;
    delete: string;
}, TSseEntity extends string, TSseContext extends object> = {
    __sqliteEntityBundle: true;
    fields: TFields;
    operationNames: TOperationNames;
    requestKeys: TRequestKeys;
    tableName: string;
    entityNameSingular: string;
    entityNamePlural: string;
    hydration?: {
        key: string;
        hydrate: () => Promise<{
            rowCount: number;
        }>;
    };
    replaceRows: (db: SqliteDatabase, rows: SqliteEntityRecordFromFields<TFields>[]) => void;
    upsertRow: (db: SqliteDatabase, row: SqliteEntityRecordFromFields<TFields>) => void;
    listRows: (db: SqliteDatabase) => SqliteEntityRecordFromFields<TFields>[];
    deleteRows: (db: SqliteDatabase, keys: Array<number | string>) => void;
    sse?: SqliteEntitySseConfig<TFields, TSseEntity, TSseContext>;
    requestHandlers: SqliteRequestHandlers;
    operationMap: {
        [TReplace in TOperationNames["replace"]]: {
            request: {
                [TReplaceKey in TRequestKeys["replace"]]: SqliteEntityRecordFromFields<TFields>[];
            };
            response: null;
        };
    } & {
        [TUpsert in TOperationNames["upsert"]]: {
            request: {
                [TUpsertKey in TRequestKeys["upsert"]]: SqliteEntityRecordFromFields<TFields>;
            };
            response: null;
        };
    } & {
        [TList in TOperationNames["list"]]: {
            request: {};
            response: SqliteEntityRecordFromFields<TFields>[];
        };
    } & {
        [TDelete in TOperationNames["delete"]]: {
            request: {
                [TDeleteKey in TRequestKeys["delete"]]: Array<number | string>;
            };
            response: null;
        };
    };
};

export type SqliteEntityClient<TRecord, TKey> = {
    replace: (records: TRecord[]) => Promise<void>;
    upsert: (record: TRecord) => Promise<void>;
    list: () => Promise<TRecord[]>;
    delete: (keys: TKey[]) => Promise<void>;
};

export type SqliteEntityClientConfig<TRecord, TKey> = {
    runtime: SqliteEntityClientRuntime;
    transport: Pick<SqliteTransport, "sendWorkerRequest">;
    getKey: (record: TRecord) => TKey;
    compare: (left: TRecord, right: TRecord) => number;
    requests: {
        replace: SqliteEntityClientRequest;
        upsert: SqliteEntityClientRequest;
        list: {
            type: string;
        };
        delete: SqliteEntityClientRequest;
    };
};

export type SqliteEntityClientRuntime = {
    shouldUseInMemoryFallback: () => boolean;
    registerInMemoryStore: (store: InMemorySqliteStore) => () => void;
};

export type SqliteEntityOperationMapFromBundle<TBundle extends {
    operationMap: Record<string, {
        request: unknown;
        response: unknown;
    }>;
}> = TBundle["operationMap"];

export type SqliteEntityRecordFromBundle<TBundle> = TBundle extends {
    upsertRow: (...args: infer TArgs) => void;
} ? TArgs extends [
    SqliteDatabase,
    infer TRow
] ? TRow : never : never;

export type SqliteEntitySpec<TFields extends SqliteEntityFields = SqliteEntityFields, TSingular extends string = string, TPlural extends string = string, TRequestKeys extends {
    replace: string;
    upsert: string;
    delete: string;
} = {
    replace: string;
    upsert: string;
    delete: string;
}, TSseEntity extends string = string, TSseContext extends object = object> = {
    entityNameSingular: TSingular;
    entityNamePlural: TPlural;
    tableName: string;
    fields: TFields;
    keywordFields?: Array<keyof TFields & string>;
    softDelete?: {
        enabled: boolean;
        columnName?: string;
    };
    orderBy?: string;
    requestKeys: TRequestKeys;
    sse?: SqliteEntitySseConfig<TFields, TSseEntity, TSseContext>;
    hydration?: {
        key: string;
        hydrate: () => Promise<{
            rowCount: number;
        }>;
    };
};

export type SqliteEntitySseConfig<TFields extends SqliteEntityFields, TSseEntity extends string, TSseContext extends object> = {
    entity: TSseEntity;
    hydrationEntityKey?: string;
    mapCreate?: (payload: SqliteEntityRecordFromFields<TFields>, context: TSseContext) => SqliteEntityRecordFromFields<TFields> | null;
    mapUpdate?: (payload: SqliteEntityRecordFromFields<TFields>, context: TSseContext) => SqliteEntityRecordFromFields<TFields> | null;
    mapDeleteKeys?: (payload: SqliteEntityDeletePayloadFromFields<TFields>, context: TSseContext) => Array<number | string>;
};

export type SqliteHydrationEntityStateRecord = {
    entityKey: string;
    appliedRevision: number;
    isStale: boolean;
    lastHydratedAt: number | null;
    lastRowCount: number | null;
    lastError: string | null;
};

export type SqliteMigration = (db: SqliteDatabase) => void;

export type SqliteOperationCoordinator = {
    runDatabaseExclusive: <T>(operation: (lockOwner: SqliteOperationLockOwner) => Promise<T>, lockOwner?: SqliteOperationLockOwner) => Promise<T>;
    runEntityExclusive: <T>(entityKey: string, operation: (lockOwner: SqliteOperationLockOwner) => Promise<T>, lockOwner?: SqliteOperationLockOwner) => Promise<T>;
    runHydrationExclusive: (operation: (signal: AbortSignal, lockOwner: SqliteOperationLockOwner) => Promise<void>) => Promise<void>;
    abortHydration: (reason?: string) => void;
    awaitHydrationIdle: () => Promise<void>;
};

export type SqliteOperationLockOwner = {
    readonly [sqliteOperationLockOwnerBrand]: true;
};

export type SqliteRequestHandler = (db: SqliteDatabase, request: WorkerRequest) => WorkerResponseResult | Promise<WorkerResponseResult>;

export type SqliteRequestHandlers = Partial<Record<string, SqliteRequestHandler>>;

export type SqliteStatement = {
    bind: (value: readonly unknown[]) => SqliteStatement;
    step: () => boolean;
    get: (target: unknown[]) => unknown[];
    getColumnNames?: (target?: string[]) => string[];
    finalize: () => number | undefined;
};

export type SqliteTransport = {
    sendRequest: <TResponse = unknown>(type: string, payload?: Record<string, unknown>) => Promise<TResponse>;
    sendWorkerRequest: <T extends WorkerResponseResult>(payload: {
        type: string;
    } & Record<string, unknown>) => Promise<T>;
};

export type SqliteTransportRuntime = {
    shouldUseInMemoryFallback: () => boolean;
    ensureInitialized: () => Promise<void>;
    send: <T extends WorkerResponseResult>(payload: WorkerRequestInput) => Promise<T>;
};

export type SqliteWorkerEntityBundleConfig = {
    requestHandlers: SqliteRequestHandlers;
};

export type SqliteWorkerRuntimeConfig = {
    dbFile: string;
    migrations: SqliteMigration[];
    requestHandlers: SqliteRequestHandlers;
    debug?: boolean;
    bootLogPrefix?: string;
};

export type WorkerRequest = {
    id: number;
    type: string;
    [key: string]: unknown;
};

export type WorkerRequestInput = Omit<WorkerRequest, "id">;

export type WorkerResponse = {
    id: number;
    ok: false;
    error: string;
} | {
    id: number;
    ok: true;
    result: unknown;
};

export type WorkerResponseResult = Extract<WorkerResponse, {
    ok: true;
}>["result"];

export declare function createDatabaseOwnerStore({ key, getStorage }: CreateDatabaseOwnerStoreConfig): DatabaseOwnerStore;

export declare function createHydrationContributorRegistry(): HydrationContributorRegistry;

export declare function createHydrationController<TLockOwner = unknown>(config: CreateHydrationControllerConfig<TLockOwner>): HydrationController;

export declare function createHydrationEntityClient(config: {
    runtime: HydrationEntityClientRuntime;
    transport: Pick<SqliteTransport, "sendWorkerRequest">;
}): HydrationEntityClient;

export declare function createHydrationGate(config?: CreateHydrationGateConfig): HydrationGate;

export declare function createHydrationRequestQueue(config?: CreateHydrationRequestQueueConfig): HydrationRequestQueue;

export declare function createHydrationStatus(config?: CreateHydrationStatusConfig): HydrationStatus;

export declare function createLocalReflectionQueue(config: CreateLocalReflectionQueueConfig): LocalReflectionQueue;

Owns worker lifecycle, initialization, pending requests, fallback stores and deterministic teardown.

/** Owns worker lifecycle, initialization, pending requests, fallback stores and deterministic teardown. */
export declare function createManagedSqliteRuntime(config: ManagedSqliteRuntimeConfig): ManagedSqliteRuntime;

export declare function createOfflineDataLifecycle(config: CreateOfflineDataLifecycleConfig): OfflineDataLifecycle;

Captures a transport request as a replayable command; transport-specific URL resolution stays injected.

/** Captures a transport request as a replayable command; transport-specific URL resolution stays injected. */
export declare function createOfflineQueueCapture<TRequest extends OfflineQueueCaptureRequest>(config: CreateOfflineQueueCaptureConfig<TRequest>): (request: TRequest) => Promise<OfflineSyncCommand>;

export declare function createOfflineQueueClient(config: CreateOfflineQueueClientConfig): OfflineQueueClient;

Framework-neutral observable queue status with non-blocking persistence refreshes.

/** Framework-neutral observable queue status with non-blocking persistence refreshes. */
export declare function createOfflineQueueStatus(config: CreateOfflineQueueStatusConfig): OfflineQueueStatus;

export declare function createOpfsDatabaseFiles(config: CreateOpfsDatabaseFilesConfig): OpfsDatabaseFiles;

export declare function createSqlConsoleClient(config: CreateSqlConsoleClientConfig): SqlConsoleClient;

export declare function createSqliteEntityBundle<const TFields extends SqliteEntityFields, const TSingular extends string, const TPlural extends string, const TRequestKeys extends {
    replace: string;
    upsert: string;
    delete: string;
}, const TSseEntity extends string = string, const TSseContext extends object = object>(spec: SqliteEntitySpec<TFields, TSingular, TPlural, TRequestKeys, TSseEntity, TSseContext>): SqliteEntityBundle<TFields, SqliteEntityOperationNames<TSingular, TPlural>, TRequestKeys, TSseEntity, TSseContext>;

export declare function createSqliteEntityClient<TRecord, TKey>(config: SqliteEntityClientConfig<TRecord, TKey>): SqliteEntityClient<TRecord, TKey>;

Creates isolated local queues with optional cross-context serialization through Web Locks.

/** Creates isolated local queues with optional cross-context serialization through Web Locks. */
export declare function createSqliteOperationCoordinator(config: CreateSqliteOperationCoordinatorConfig): SqliteOperationCoordinator;

export declare function createSqliteRequestHandlers<THandlers extends SqliteRequestHandlers>(handlers: THandlers): THandlers;

export declare function createSqliteTransport({ runtime, createUnavailableError, }: CreateSqliteTransportConfig): SqliteTransport;

export declare function createSqliteWorkerRuntime(config: SqliteWorkerRuntimeConfig): {
    attach: (worker: WorkerLike) => void;
    handleRequest: (worker: WorkerLike, request: WorkerRequest) => Promise<void>;
};

export declare function createSqliteWorkerRuntimeConfig(input: CreateSqliteWorkerRuntimeConfigInput): SqliteWorkerRuntimeConfig;

export declare function deleteOfflineCommands(db: SqliteDatabase, commandIds: string[]): void;

export declare function deleteSqliteRowsByKey(db: SqliteDatabase, table: string, keyColumn: string, values: Array<number | string>): void;

export declare function dispatchSqliteRequest(db: SqliteDatabase, request: WorkerRequest, handlers: SqliteRequestHandlers): Promise<WorkerResponseResult | undefined>;

export declare function enqueueOfflineCommand(db: SqliteDatabase, command: OfflineSyncCommandRecord): void;

export declare function executePagedQuery(db: SqliteDatabase, request: SqlPagedQueryRequest): SqlPagedQueryResult;

export declare function executeSqlScript(db: SqliteDatabase, script: string): SqlExecutionResult;

export declare function getOfflineQueueSize(db: SqliteDatabase): number;

export declare function getOfflineQueueStatusCounts(db: SqliteDatabase): OfflineQueueStatusCounts;

export declare function getPendingOfflineCommands(db: SqliteDatabase, batchSize: number): OfflineQueuedCommand[];

export declare function listHydrationEntityStates(db: SqliteDatabase): SqliteHydrationEntityStateRecord[];

export declare function listSqliteRows<T>(db: SqliteDatabase, sql: string, mapRow: (row: unknown[]) => T): T[];

export declare function markOfflineCommandsPermanentlyFailed(db: SqliteDatabase, commandIds: string[], lastError: string | null): void;

export declare function markOfflineCommandsRetryable(db: SqliteDatabase, commandIds: string[], lastError: string | null, maxRetryCount: number): void;

export declare function mergeSqliteRequestHandlers(...handlersList: SqliteRequestHandlers[]): SqliteRequestHandlers;

export declare function replayOfflineSyncBatch(args: {
    batchSize: number;
    maxAttempts: number;
    dependencies: OfflineSyncReplayDependencies;
}): Promise<number>;

export declare function runSqliteTransaction(db: SqliteDatabase, action: () => void): void;

export declare function upsertHydrationEntityState(db: SqliteDatabase, state: SqliteHydrationEntityStateRecord): void;