import { Devtools, SyncState, UnknownError } from '@livestore/common';
import { EventSequenceNumber } from '@livestore/common/schema';
import { Schema } from '@livestore/utils/effect';
export declare const WorkerArgv: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
    clientId: typeof Schema.String;
    storeId: typeof Schema.String;
    sessionId: typeof Schema.String;
    extraArgs: Schema.UndefinedOr<Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
}>>;
export declare const StorageTypeInMemory: Schema.Struct<{
    type: Schema.Literal<["in-memory"]>;
    /**
     * Only works with single-threaded leader thread for now.
     * Should be mostly used for testing.
     */
    importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
}>;
export type StorageTypeInMemory = typeof StorageTypeInMemory.Type;
export declare const StorageTypeFs: Schema.Struct<{
    type: Schema.Literal<["fs"]>;
    /**
     * Where to store the database files
     *
     * @default Current working directory
     */
    baseDirectory: Schema.optional<typeof Schema.String>;
}>;
export type StorageTypeFs = typeof StorageTypeFs.Type;
export declare const StorageType: Schema.Union<[Schema.Struct<{
    type: Schema.Literal<["in-memory"]>;
    /**
     * Only works with single-threaded leader thread for now.
     * Should be mostly used for testing.
     */
    importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
}>, Schema.Struct<{
    type: Schema.Literal<["fs"]>;
    /**
     * Where to store the database files
     *
     * @default Current working directory
     */
    baseDirectory: Schema.optional<typeof Schema.String>;
}>]>;
export type StorageType = typeof StorageType.Type;
export type StorageTypeEncoded = typeof StorageType.Encoded;
export declare const SyncBackendOptions: Schema.Record$<typeof Schema.String, Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
export type SyncBackendOptions = Record<string, Schema.JsonValue>;
declare const LeaderWorkerOuterInitialMessage_base: Schema.TaggedRequestClass<LeaderWorkerOuterInitialMessage, "InitialMessage", {
    readonly _tag: Schema.tag<"InitialMessage">;
} & {
    port: Schema.Schema<MessagePort, MessagePort, never>;
}, typeof Schema.Void, typeof Schema.Never>;
export declare class LeaderWorkerOuterInitialMessage extends LeaderWorkerOuterInitialMessage_base {
}
declare const LeaderWorkerOuterRequest_base: typeof LeaderWorkerOuterInitialMessage;
export declare class LeaderWorkerOuterRequest extends LeaderWorkerOuterRequest_base {
}
declare const LeaderWorkerInnerInitialMessage_base: Schema.TaggedRequestClass<LeaderWorkerInnerInitialMessage, "InitialMessage", {
    readonly _tag: Schema.tag<"InitialMessage">;
} & {
    storeId: typeof Schema.String;
    clientId: typeof Schema.String;
    storage: Schema.Union<[Schema.Struct<{
        type: Schema.Literal<["in-memory"]>;
        /**
         * Only works with single-threaded leader thread for now.
         * Should be mostly used for testing.
         */
        importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
    }>, Schema.Struct<{
        type: Schema.Literal<["fs"]>;
        /**
         * Where to store the database files
         *
         * @default Current working directory
         */
        baseDirectory: Schema.optional<typeof Schema.String>;
    }>]>;
    syncPayloadEncoded: Schema.UndefinedOr<Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
    devtools: Schema.Union<[Schema.Struct<{
        enabled: Schema.Literal<[true]>;
        schemaPath: typeof Schema.String;
        port: typeof Schema.Number;
        host: typeof Schema.String;
        schemaAlias: typeof Schema.String;
        useExistingDevtoolsServer: typeof Schema.Boolean;
    }>, Schema.Struct<{
        enabled: Schema.Literal<[false]>;
    }>]>;
}, typeof Schema.Void, typeof UnknownError>;
export declare class LeaderWorkerInnerInitialMessage extends LeaderWorkerInnerInitialMessage_base {
}
declare const LeaderWorkerInnerBootStatusStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerBootStatusStream, "BootStatusStream", {
    readonly _tag: Schema.tag<"BootStatusStream">;
}, Schema.Union<[Schema.Struct<{
    stage: Schema.Literal<["loading"]>;
}>, Schema.Struct<{
    stage: Schema.Literal<["migrating"]>;
    progress: Schema.Struct<{
        done: typeof Schema.Number;
        total: typeof Schema.Number;
    }>;
}>, Schema.Struct<{
    stage: Schema.Literal<["rehydrating"]>;
    progress: Schema.Struct<{
        done: typeof Schema.Number;
        total: typeof Schema.Number;
    }>;
}>, Schema.Struct<{
    stage: Schema.Literal<["syncing"]>;
    progress: Schema.Struct<{
        done: typeof Schema.Number;
        total: typeof Schema.Number;
    }>;
}>, Schema.Struct<{
    stage: Schema.Literal<["done"]>;
}>, Schema.Struct<{
    stage: Schema.Literal<["warning"]>;
    reason: Schema.Literal<["private-browsing", "storage-unavailable", "unknown"]>;
    message: typeof Schema.String;
}>]>, typeof Schema.Never>;
export declare class LeaderWorkerInnerBootStatusStream extends LeaderWorkerInnerBootStatusStream_base {
}
declare const LeaderWorkerInnerPullStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerPullStream, "PullStream", {
    readonly _tag: Schema.tag<"PullStream">;
} & {
    cursor: Schema.SchemaClass<{
        readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
        readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
        readonly rebaseGeneration: number;
    }, {
        readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
        readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
        readonly rebaseGeneration: number;
    }, never>;
}, Schema.Struct<{
    payload: typeof SyncState.PayloadUpstream;
}>, typeof Schema.Never>;
export declare class LeaderWorkerInnerPullStream extends LeaderWorkerInnerPullStream_base {
}
declare const LeaderWorkerInnerStreamEvents_base: Schema.TaggedRequestClass<LeaderWorkerInnerStreamEvents, "StreamEvents", {
    readonly _tag: Schema.tag<"StreamEvents">;
} & {
    readonly since: Schema.optional<Schema.Struct<{
        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
        rebaseGeneration: typeof Schema.Int;
    }> & {
        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
    }>;
    readonly until: Schema.optional<Schema.Struct<{
        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
        rebaseGeneration: typeof Schema.Int;
    }> & {
        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
    }>;
    readonly filter: Schema.optional<Schema.Array$<typeof Schema.String>>;
    readonly clientIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
    readonly sessionIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
    readonly batchSize: Schema.optional<Schema.filter<typeof Schema.Int>>;
    readonly includeClientOnly: Schema.optional<typeof Schema.Boolean>;
}, Schema.Struct<{
    name: typeof Schema.String;
    args: typeof Schema.Any;
    seqNum: Schema.Struct<{
        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
        rebaseGeneration: typeof Schema.Int;
    }> & {
        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
    };
    parentSeqNum: Schema.Struct<{
        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
        rebaseGeneration: typeof Schema.Int;
    }> & {
        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
    };
    clientId: typeof Schema.String;
    sessionId: typeof Schema.String;
}>, typeof Schema.Never>;
export declare class LeaderWorkerInnerStreamEvents extends LeaderWorkerInnerStreamEvents_base {
}
declare const LeaderWorkerInnerPushToLeader_base: Schema.TaggedRequestClass<LeaderWorkerInnerPushToLeader, "PushToLeader", {
    readonly _tag: Schema.tag<"PushToLeader">;
} & {
    batch: Schema.Array$<Schema.SchemaClass<{
        readonly clientId: string;
        readonly sessionId: string;
        readonly name: string;
        readonly args: any;
        readonly seqNum: {
            readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
            readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
            readonly rebaseGeneration: number;
        };
        readonly parentSeqNum: {
            readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
            readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
            readonly rebaseGeneration: number;
        };
    }, {
        readonly clientId: string;
        readonly sessionId: string;
        readonly name: string;
        readonly args: any;
        readonly seqNum: {
            readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
            readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
            readonly rebaseGeneration: number;
        };
        readonly parentSeqNum: {
            readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
            readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
            readonly rebaseGeneration: number;
        };
    }, never>>;
}, Schema.Schema<void, void, never>, Schema.Union<[typeof import("@livestore/common").LeaderAheadError, typeof import("@livestore/common").NonMonotonicBatchError, typeof import("@livestore/common").StaleRebaseGenerationError]>>;
export declare class LeaderWorkerInnerPushToLeader extends LeaderWorkerInnerPushToLeader_base {
}
declare const LeaderWorkerInnerExport_base: Schema.TaggedRequestClass<LeaderWorkerInnerExport, "Export", {
    readonly _tag: Schema.tag<"Export">;
}, Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>, typeof Schema.Never>;
export declare class LeaderWorkerInnerExport extends LeaderWorkerInnerExport_base {
}
declare const LeaderWorkerInnerGetRecreateSnapshot_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetRecreateSnapshot, "GetRecreateSnapshot", {
    readonly _tag: Schema.tag<"GetRecreateSnapshot">;
}, Schema.Struct<{
    snapshot: Schema.Schema<Uint8Array<ArrayBuffer>>;
    migrationsReport: Schema.Struct<{
        migrations: Schema.Array$<Schema.Struct<{
            tableName: typeof Schema.String;
            hashes: Schema.Struct<{
                expected: typeof Schema.Number;
                actual: Schema.optional<typeof Schema.Number>;
            }>;
        }>>;
    }>;
}>, typeof Schema.Never>;
export declare class LeaderWorkerInnerGetRecreateSnapshot extends LeaderWorkerInnerGetRecreateSnapshot_base {
}
declare const LeaderWorkerInnerExportEventlog_base: Schema.TaggedRequestClass<LeaderWorkerInnerExportEventlog, "ExportEventlog", {
    readonly _tag: Schema.tag<"ExportEventlog">;
}, Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>, typeof Schema.Never>;
export declare class LeaderWorkerInnerExportEventlog extends LeaderWorkerInnerExportEventlog_base {
}
declare const LeaderWorkerInnerGetLeaderHead_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetLeaderHead, "GetLeaderHead", {
    readonly _tag: Schema.tag<"GetLeaderHead">;
}, Schema.SchemaClass<{
    readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
    readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
    readonly rebaseGeneration: number;
}, {
    readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
    readonly client: number & import("effect/Brand").Brand<"ClientEventSequenceNumber">;
    readonly rebaseGeneration: number;
}, never>, typeof Schema.Never>;
export declare class LeaderWorkerInnerGetLeaderHead extends LeaderWorkerInnerGetLeaderHead_base {
}
declare const LeaderWorkerInnerGetLeaderSyncState_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetLeaderSyncState, "GetLeaderSyncState", {
    readonly _tag: Schema.tag<"GetLeaderSyncState">;
}, typeof SyncState.SyncState, typeof Schema.Never>;
export declare class LeaderWorkerInnerGetLeaderSyncState extends LeaderWorkerInnerGetLeaderSyncState_base {
}
declare const LeaderWorkerInnerSyncStateStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerSyncStateStream, "SyncStateStream", {
    readonly _tag: Schema.tag<"SyncStateStream">;
}, typeof SyncState.SyncState, typeof Schema.Never>;
export declare class LeaderWorkerInnerSyncStateStream extends LeaderWorkerInnerSyncStateStream_base {
}
declare const LeaderWorkerInnerGetNetworkStatus_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetNetworkStatus, "GetNetworkStatus", {
    readonly _tag: Schema.tag<"GetNetworkStatus">;
}, Schema.Struct<{
    isConnected: typeof Schema.Boolean;
    timestampMs: typeof Schema.Number;
    devtools: Schema.Struct<{
        latchClosed: typeof Schema.Boolean;
    }>;
}>, typeof Schema.Never>;
export declare class LeaderWorkerInnerGetNetworkStatus extends LeaderWorkerInnerGetNetworkStatus_base {
}
declare const LeaderWorkerInnerNetworkStatusStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerNetworkStatusStream, "NetworkStatusStream", {
    readonly _tag: Schema.tag<"NetworkStatusStream">;
}, Schema.Struct<{
    isConnected: typeof Schema.Boolean;
    timestampMs: typeof Schema.Number;
    devtools: Schema.Struct<{
        latchClosed: typeof Schema.Boolean;
    }>;
}>, typeof Schema.Never>;
export declare class LeaderWorkerInnerNetworkStatusStream extends LeaderWorkerInnerNetworkStatusStream_base {
}
declare const LeaderWorkerInnerShutdown_base: Schema.TaggedRequestClass<LeaderWorkerInnerShutdown, "Shutdown", {
    readonly _tag: Schema.tag<"Shutdown">;
}, typeof Schema.Void, typeof Schema.Never>;
export declare class LeaderWorkerInnerShutdown extends LeaderWorkerInnerShutdown_base {
}
declare const LeaderWorkerInnerExtraDevtoolsMessage_base: Schema.TaggedRequestClass<LeaderWorkerInnerExtraDevtoolsMessage, "ExtraDevtoolsMessage", {
    readonly _tag: Schema.tag<"ExtraDevtoolsMessage">;
} & {
    message: Schema.Union<[typeof Devtools.Leader.SnapshotReq, Schema.TaggedStruct<"LSD.Leader.LoadDatabaseFile.Request", {
        data: Schema.Schema<Uint8Array<ArrayBuffer>>;
        batchId: Schema.optional<typeof Schema.String>;
    } & {
        readonly requestId: typeof Schema.String;
        readonly liveStoreVersion: typeof Schema.String;
        readonly clientId: typeof Schema.String;
    }>, typeof Devtools.Leader.EventlogReq, Schema.TaggedStruct<"LSD.Leader.ResetAllData.Request", {
        mode: Schema.Literal<["all-data", "only-app-db"]>;
    } & {
        readonly requestId: typeof Schema.String;
        readonly liveStoreVersion: typeof Schema.String;
        readonly clientId: typeof Schema.String;
    }>, typeof Devtools.Leader.NetworkStatusSubscribe, typeof Devtools.Leader.NetworkStatusUnsubscribe, typeof Devtools.Leader.Disconnect, typeof Devtools.Leader.CommitEventReq, typeof Devtools.Leader.Ping, typeof Devtools.Leader.DatabaseFileInfoReq, typeof Devtools.Leader.SyncHistorySubscribe, typeof Devtools.Leader.SyncHistoryUnsubscribe, typeof Devtools.Leader.SyncingInfoReq, typeof Devtools.Leader.SyncHeadSubscribe, typeof Devtools.Leader.SyncHeadUnsubscribe, Schema.TaggedStruct<"LSD.Leader.SetSyncLatch.Request", {
        closeLatch: typeof Schema.Boolean;
    } & {
        readonly requestId: typeof Schema.String;
        readonly liveStoreVersion: typeof Schema.String;
        readonly clientId: typeof Schema.String;
    }>]>;
}, typeof Schema.Void, typeof Schema.Never>;
export declare class LeaderWorkerInnerExtraDevtoolsMessage extends LeaderWorkerInnerExtraDevtoolsMessage_base {
}
export declare const LeaderWorkerInnerRequest: Schema.Union<[typeof LeaderWorkerInnerInitialMessage, typeof LeaderWorkerInnerBootStatusStream, typeof LeaderWorkerInnerPullStream, typeof LeaderWorkerInnerStreamEvents, typeof LeaderWorkerInnerPushToLeader, typeof LeaderWorkerInnerExport, typeof LeaderWorkerInnerGetRecreateSnapshot, typeof LeaderWorkerInnerExportEventlog, typeof LeaderWorkerInnerGetLeaderHead, typeof LeaderWorkerInnerGetLeaderSyncState, typeof LeaderWorkerInnerSyncStateStream, typeof LeaderWorkerInnerGetNetworkStatus, typeof LeaderWorkerInnerNetworkStatusStream, typeof LeaderWorkerInnerShutdown, typeof LeaderWorkerInnerExtraDevtoolsMessage]>;
export type LeaderWorkerInnerRequest = typeof LeaderWorkerInnerRequest.Type;
export {};
//# sourceMappingURL=worker-schema.d.ts.map