@live-state/sync 0.0.6 → 0.0.7-canary-1

package/dist/index-P-s1Yf1S.d.ts

@@ -1,520 +0,0 @@
-import { z } from 'zod';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-type LiveTypeMeta = {};
-type MutationType = "set";
-type StorageFieldType = {
-    type: string;
-    nullable: boolean;
-    default?: any;
-    unique?: boolean;
-    index?: boolean;
-    primary?: boolean;
-    references?: string;
-};
-declare abstract class LiveType<Value = any, Meta extends LiveTypeMeta = LiveTypeMeta, EncodeInput = Partial<Value> | Value, DecodeInput = {
-    value: Value;
-    _meta: keyof Meta extends never ? never : Meta;
-}> {
-    readonly _value: Value;
-    readonly _meta: Meta;
-    readonly _encodeInput: EncodeInput;
-    readonly _decodeInput: DecodeInput;
-    abstract encodeMutation(mutationType: MutationType, input: EncodeInput, timestamp: string): DecodeInput;
-    /**
-     * Merges the materialized shape with the encoded mutation
-     * @param mutationType The type of mutation
-     * @param encodedMutation The encoded mutation
-     * @param materializedShape The materialized shape
-     * @returns A tuple of the new materialized shape and the accepted diff
-     */
-    abstract mergeMutation(mutationType: MutationType, encodedMutation: DecodeInput, materializedShape?: MaterializedLiveType<LiveType<Value, Meta>>): [MaterializedLiveType<LiveType<Value, Meta>>, DecodeInput | null];
-    abstract getStorageFieldType(): StorageFieldType;
-}
-type LiveTypeAny = LiveType<any, LiveTypeMeta, any, any>;
-type InferLiveType<T extends LiveTypeAny> = T["_value"] extends Record<string, LiveTypeAny> ? {
-    [K in keyof T["_value"]]: InferLiveType<T["_value"][K]>;
-} : T["_value"];
-type InferIndex<T extends LiveTypeAny> = string;
-
-declare class NullableLiveType<T extends LiveTypeAny> extends LiveType<T["_value"] | null, T["_meta"], T["_encodeInput"], T["_decodeInput"]> {
-    readonly inner: T;
-    constructor(inner: T);
-    encodeMutation(mutationType: MutationType, input: T["_value"] | null, timestamp: string): T["_decodeInput"];
-    mergeMutation(mutationType: MutationType, encodedMutation: T["_decodeInput"], materializedShape?: MaterializedLiveType<LiveType<T["_value"] | null, T["_meta"], T["_value"] | Partial<T["_value"] | null>, T["_decodeInput"]>> | undefined): [
-        MaterializedLiveType<LiveType<T["_value"] | null, T["_meta"], T["_value"] | Partial<T["_value"] | null>, T["_decodeInput"]>>,
-        T["_decodeInput"] | null
-    ];
-    getStorageFieldType(): StorageFieldType;
-}
-type LiveAtomicTypeMeta = {
-    timestamp: string | null;
-} & LiveTypeMeta;
-declare class LiveAtomicType<Value, DefaultValue = undefined> extends LiveType<Value, LiveAtomicTypeMeta, Value, {
-    value: Value;
-    _meta: LiveAtomicTypeMeta;
-}> {
-    readonly storageType: string;
-    readonly convertFunc?: (value: any) => Value;
-    readonly isIndex: boolean;
-    readonly isUnique: boolean;
-    readonly defaultValue: DefaultValue;
-    readonly foreignReference?: string;
-    readonly isPrimary: boolean;
-    constructor(storageType: string, convertFunc?: (value: any) => Value, index?: boolean, unique?: boolean, defaultValue?: DefaultValue, references?: string, primary?: boolean);
-    encodeMutation(mutationType: MutationType, input: Value, timestamp: string): {
-        value: Value;
-        _meta: LiveAtomicTypeMeta;
-    };
-    mergeMutation(mutationType: MutationType, encodedMutation: {
-        value: Value;
-        _meta: LiveAtomicTypeMeta;
-    }, materializedShape?: MaterializedLiveType<LiveType<Value, LiveAtomicTypeMeta, Value | Partial<Value>, {
-        value: Value;
-        _meta: LiveAtomicTypeMeta;
-    }>>): [
-        MaterializedLiveType<LiveType<Value, LiveAtomicTypeMeta, Value | Partial<Value>, {
-            value: Value;
-            _meta: LiveAtomicTypeMeta;
-        }>>,
-        {
-            value: Value;
-            _meta: LiveAtomicTypeMeta;
-        } | null
-    ];
-    getStorageFieldType(): StorageFieldType;
-    unique(): LiveAtomicType<Value, undefined>;
-    index(): LiveAtomicType<Value, undefined>;
-    default(value: Value): LiveAtomicType<Value, Value>;
-    primary(): LiveAtomicType<Value, undefined>;
-    nullable(): NullableLiveType<this>;
-}
-declare class LiveString extends LiveAtomicType<string> {
-    private constructor();
-    static create(): LiveString;
-    static createId(): LiveAtomicType<string, undefined>;
-    static createReference(foreignField: `${string}.${string}`): LiveString;
-}
-
-/** biome-ignore-all lint/complexity/noBannedTypes: false positive */
-
-type InferLiveObjectWithoutRelations<T extends LiveObjectAny> = {
-    [K in keyof T["fields"]]: InferLiveType<T["fields"][K]>;
-};
-type InferLiveObject<T extends LiveObjectAny, Include extends IncludeClause<T> | undefined = undefined> = InferLiveObjectWithoutRelations<T> & (Include extends IncludeClause<T> ? {
-    [K in keyof T["relations"] as Include[K] extends true | IncludeClause<T["relations"][K]["entity"]> ? K : never]: Include[K] extends true ? T["relations"][K]["type"] extends "one" ? T["fields"][Exclude<T["relations"][K]["relationalColumn"], undefined>] extends NullableLiveType<any> ? InferLiveObject<T["relations"][K]["entity"]> | null : InferLiveObject<T["relations"][K]["entity"]> : InferLiveObject<T["relations"][K]["entity"]>[] : Include[K] extends IncludeClause<T["relations"][K]["entity"]> ? T["relations"][K]["type"] extends "one" ? T["fields"][Exclude<T["relations"][K]["relationalColumn"], undefined>] extends NullableLiveType<any> ? InferLiveObject<T["relations"][K]["entity"], Include[K]> | null : InferLiveObject<T["relations"][K]["entity"], Include[K]> : InferLiveObject<T["relations"][K]["entity"], Include[K]>[] : never;
-} : {});
-type InferRelationalColumns<T extends Record<string, RelationAny>> = {
-    [K in keyof T as T[K]["type"] extends "many" ? never : T[K]["relationalColumn"]]: T[K]["required"] extends true ? InferIndex<T[K]["entity"]> : InferIndex<T[K]["entity"]> | null;
-};
-type InferLiveObjectWithRelationalIds<T extends LiveObjectAny> = keyof T["relations"] extends string ? InferLiveObjectWithoutRelations<T> & InferRelationalColumns<T["relations"]> : InferLiveObjectWithoutRelations<T>;
-type LiveObjectMutationInput<TSchema extends LiveObjectAny> = Partial<InferLiveObjectWithRelationalIds<TSchema>>;
-declare class LiveObject<TName extends string, TSchema extends Record<string, LiveTypeAny>, TRelations extends Record<string, RelationAny>> extends LiveType<TSchema, LiveTypeMeta, LiveObjectMutationInput<any>, Record<string, MaterializedLiveType<LiveTypeAny>>> {
-    readonly name: TName;
-    readonly fields: TSchema;
-    readonly relations: TRelations;
-    constructor(name: TName, fields: TSchema, relations?: TRelations);
-    encodeMutation(_mutationType: MutationType, input: LiveObjectMutationInput<this>, timestamp: string): Record<string, any>;
-    mergeMutation(mutationType: MutationType, encodedMutations: Record<string, MaterializedLiveType<LiveTypeAny>>, materializedShape?: MaterializedLiveType<this> | undefined): [MaterializedLiveType<this>, Record<string, any> | null];
-    setRelations<TRelations extends Record<string, RelationAny>>(relations: TRelations): LiveObject<this["name"], this["fields"], TRelations>;
-    getStorageFieldType(): StorageFieldType;
-    static create<TName extends string, TSchema extends Record<string, LiveTypeAny>>(name: TName, schema: TSchema): LiveObject<TName, TSchema, never>;
-}
-type LiveObjectAny = LiveObject<string, Record<string, LiveTypeAny>, any>;
-declare class Relation<TEntity extends LiveObjectAny, TSourceEntity extends LiveObjectAny, TType extends "one" | "many", TRelationalColumn extends keyof TSourceEntity["fields"], TForeignColumn extends keyof TEntity["fields"], TRequired extends boolean> extends LiveType<InferIndex<TEntity>, {
-    timestamp: string | null;
-} & LiveTypeMeta> {
-    readonly entity: TEntity;
-    readonly type: TType;
-    readonly required: TRequired;
-    readonly relationalColumn?: TRelationalColumn;
-    readonly foreignColumn?: TForeignColumn;
-    readonly sourceEntity: TSourceEntity;
-    private constructor();
-    encodeMutation(mutationType: MutationType, input: string, timestamp: string): {
-        value: string;
-        _meta: {
-            timestamp: string;
-        };
-    };
-    mergeMutation(mutationType: MutationType, encodedMutation: {
-        value: string;
-        _meta: {
-            timestamp: string;
-        };
-    }, materializedShape?: MaterializedLiveType<LiveString> | undefined): [
-        MaterializedLiveType<LiveString>,
-        {
-            value: string;
-            _meta: {
-                timestamp: string;
-            };
-        } | null
-    ];
-    getStorageFieldType(): StorageFieldType;
-    toJSON(): {
-        entityName: string;
-        type: TType;
-        required: TRequired;
-        relationalColumn: TRelationalColumn | undefined;
-        foreignColumn: TForeignColumn | undefined;
-    };
-    static createOneFactory<TOriginEntity extends LiveObjectAny>(): <TEntity extends LiveObjectAny, TColumn extends keyof TOriginEntity["fields"], TRequired extends boolean = false>(entity: TEntity, column: TColumn, required?: TRequired) => Relation<TEntity, TOriginEntity, "one", TColumn, never, TRequired>;
-    static createManyFactory<TOriginEntity extends LiveObjectAny>(): <TEntity extends LiveObjectAny, TColumn extends keyof TEntity["fields"], TRequired extends boolean = false>(entity: TEntity, foreignColumn: TColumn, required?: TRequired) => Relation<TEntity, TOriginEntity, "many", never, TColumn, TRequired>;
-}
-type RelationAny = Relation<LiveObjectAny, LiveObjectAny, any, any, any, any>;
-type MaterializedLiveType<T extends LiveTypeAny> = {
-    value: T["_value"] extends Record<string, LiveTypeAny> ? {
-        [K in keyof T["_value"]]: MaterializedLiveType<T["_value"][K]>;
-    } : T["_value"];
-    _meta: T["_meta"];
-};
-type ExtractObjectValues<T> = T[keyof T];
-type RelationsDecl<TObjectName extends string = string, TRelations extends Record<string, RelationAny> = Record<string, RelationAny>> = {
-    $type: "relations";
-    objectName: TObjectName;
-    relations: TRelations;
-};
-type ParseRelationsFromSchema<TRawSchema extends RawSchema, TObjectName extends string> = ExtractObjectValues<{
-    [K in keyof TRawSchema]: TRawSchema[K] extends RelationsDecl<infer TObjectName_, any> ? TObjectName_ extends TObjectName ? {
-        [K2 in keyof TRawSchema[K]["relations"]]: Relation<ParseObjectFromSchema<TRawSchema, TRawSchema[K]["relations"][K2]["entity"]["name"]>, TRawSchema[K]["relations"][K2]["sourceEntity"], TRawSchema[K]["relations"][K2]["type"], Exclude<TRawSchema[K]["relations"][K2]["relationalColumn"], undefined>, Exclude<TRawSchema[K]["relations"][K2]["foreignColumn"], undefined>, TRawSchema[K]["relations"][K2]["required"]>;
-    } : never : never;
-}>;
-type ParseObjectFromSchema<TRawSchema extends RawSchema, TObjectName extends string> = ExtractObjectValues<{
-    [K in keyof TRawSchema]: TRawSchema[K] extends LiveObjectAny ? TRawSchema[K]["name"] extends TObjectName ? LiveObject<TRawSchema[K]["name"], TRawSchema[K]["fields"], ParseRelationsFromSchema<TRawSchema, TRawSchema[K]["name"]>> : never : never;
-}>;
-type RawSchema = Record<string, LiveObjectAny | RelationsDecl>;
-type Schema<TRawSchema extends RawSchema> = {
-    [K in keyof TRawSchema as TRawSchema[K] extends LiveObjectAny ? TRawSchema[K]["name"] : never]: TRawSchema[K] extends LiveObjectAny ? ParseObjectFromSchema<TRawSchema, TRawSchema[K]["name"]> : never;
-};
-type WhereClause<T extends LiveObjectAny> = ({
-    [K in keyof T["fields"]]?: InferLiveType<T["fields"][K]> | ({
-        $eq?: InferLiveType<T["fields"][K]>;
-        $in?: InferLiveType<T["fields"][K]>[];
-        $not?: InferLiveType<T["fields"][K]> | {
-            $in?: InferLiveType<T["fields"][K]>[];
-            $eq?: InferLiveType<T["fields"][K]>;
-        };
-    } & (Exclude<InferLiveType<T["fields"][K]>, null | undefined> extends number | Date ? {
-        $gt?: InferLiveType<T["fields"][K]>;
-        $gte?: InferLiveType<T["fields"][K]>;
-        $lt?: InferLiveType<T["fields"][K]>;
-        $lte?: InferLiveType<T["fields"][K]>;
-    } : {}));
-} & {
-    [K in keyof T["relations"]]?: WhereClause<T["relations"][K]["entity"]>;
-}) | {
-    $and?: WhereClause<T>[];
-    $or?: WhereClause<T>[];
-};
-type IncludeClause<T extends LiveObjectAny> = {
-    [K in keyof T["relations"]]?: boolean | IncludeClause<T["relations"][K]["entity"]>;
-};
-type GetFieldType<T> = T extends NullableLiveType<any> ? T["inner"] : T;
-type HasDefaultValue<T> = T extends LiveAtomicType<any, undefined> ? false : true;
-type InferInsert<T extends LiveObjectAny> = {
-    [K in keyof T["fields"] as HasDefaultValue<GetFieldType<T["fields"][K]>> extends true ? never : K]: InferLiveType<T["fields"][K]>;
-} & {
-    [K in keyof T["fields"] as HasDefaultValue<GetFieldType<T["fields"][K]>> extends false ? never : K]?: InferLiveType<T["fields"][K]>;
-};
-type InferUpdate<T extends LiveObjectAny> = Omit<LiveObjectMutationInput<T>, "id">;
-
-type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
-type ConditionalPromise<T, P extends boolean> = P extends true ? Promise<T> : T;
-type PromiseOrSync<T> = T | Promise<T>;
-type Generatable<T, Arg = never> = T | ((arg: Arg) => T);
-
-type Simplify<T> = T extends Record<string, unknown> ? {
-    [K in keyof T]: Simplify<T[K]>;
-} : T extends Array<infer U> ? Array<Simplify<U>> : T;
-declare const LogLevel: {
-    readonly CRITICAL: 0;
-    readonly ERROR: 1;
-    readonly WARN: 2;
-    readonly INFO: 3;
-    readonly DEBUG: 4;
-};
-type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
-
-declare const querySchema: z.ZodObject<{
-    resource: z.ZodString;
-    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    include: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    lastSyncedAt: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        direction: z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-type RawQueryRequest = z.infer<typeof querySchema>;
-
-/** biome-ignore-all lint/complexity/noBannedTypes: <explanation> */
-
-type InferQueryResult<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection>, TSingle extends boolean = false> = TSingle extends true ? Simplify<InferLiveObject<TCollection, TInclude>> | undefined : Simplify<InferLiveObject<TCollection, TInclude>>[];
-declare class QueryBuilder<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection> = {}, TSingle extends boolean = false, TShouldAwait extends boolean = false> {
-    private _collection;
-    private _client;
-    private _where;
-    private _include;
-    private _limit?;
-    private _single?;
-    private _sort?;
-    private _shouldAwait?;
-    private constructor();
-    where(where: WhereClause<TCollection>): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
-    include<TNewInclude extends IncludeClause<TCollection>>(include: TNewInclude): QueryBuilder<TCollection, TInclude & TNewInclude, TSingle, TShouldAwait>;
-    limit(limit: number): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
-    one(id: string): QueryBuilder<TCollection, TInclude, true, TShouldAwait>;
-    first(where?: WhereClause<TCollection>): QueryBuilder<TCollection, TInclude, true, TShouldAwait>;
-    orderBy(key: keyof TCollection["fields"], direction?: "asc" | "desc"): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
-    toJSON(): {
-        resource: string;
-        where: WhereClause<TCollection>;
-        include: TInclude;
-        limit: number | undefined;
-        sort: {
-            key: string;
-            direction: "asc" | "desc";
-        }[] | undefined;
-    };
-    buildQueryRequest(): RawQueryRequest;
-    get(): ConditionalPromise<InferQueryResult<TCollection, TInclude, TSingle>, TShouldAwait>;
-    subscribe(callback: (value: InferQueryResult<TCollection, TInclude, TSingle>) => void): () => void;
-}
-
-/**
- * Extracts the output type from a Standard Schema validator.
- * Supports Standard Schema (via ~standard property) and Zod schemas (via _output property for backward compatibility).
- */
-type InferSchema<T> = T extends {
-    "~standard": {
-        types?: {
-            output: infer U;
-        };
-    };
-} ? U : T extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<T> : T extends {
-    _output: infer U;
-} ? U : never;
-/**
- * Helper type for custom mutation functions.
- * When the input type is `never` or `undefined`, the function has no parameters.
- */
-type CustomMutationFunction<TInput, TOutput> = [TInput] extends [never] | [undefined] ? () => Promisify<TOutput> : (input: TInput) => Promisify<TOutput>;
-/**
- * Simplified router constraint for client-side usage.
- * This avoids importing server-internal types like Storage and Hooks,
- * which can cause type incompatibilities when the package is bundled.
- */
-type ClientRouterConstraint = {
-    routes: Record<string, {
-        resourceSchema: LiveObjectAny;
-        customMutations: Record<string, {
-            inputValidator: StandardSchemaV1<any, any>;
-            handler: (...args: any[]) => any;
-        }>;
-    }>;
-};
-type Client$1<TRouter extends ClientRouterConstraint, TShouldAwait extends boolean = false> = {
-    query: {
-        [K in keyof TRouter["routes"]]: QueryBuilder<TRouter["routes"][K]["resourceSchema"], {}, false, TShouldAwait>;
-    };
-    mutate: {
-        [K in keyof TRouter["routes"]]: {
-            insert: (input: Simplify<InferInsert<TRouter["routes"][K]["resourceSchema"]>>) => ConditionalPromise<void, TShouldAwait>;
-            update: (id: string, value: Simplify<InferUpdate<TRouter["routes"][K]["resourceSchema"]>>) => ConditionalPromise<void, TShouldAwait>;
-        } & {
-            [K2 in keyof TRouter["routes"][K]["customMutations"]]: CustomMutationFunction<InferSchema<TRouter["routes"][K]["customMutations"][K2]["inputValidator"]>, ReturnType<TRouter["routes"][K]["customMutations"][K2]["handler"]>>;
-        };
-    };
-};
-
-declare const useLiveQuery: <T extends {
-    get: () => U;
-    subscribe: (cb: (v: U) => void) => () => void;
-}, U>(observable: T) => ReturnType<T["get"]>;
-declare const useLoadData: (client: Client<ClientRouterConstraint>["client"], query: QueryBuilder<any, any>) => void;
-
-declare const serverMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"REJECT">;
-    resource: z.ZodString;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"REPLY">;
-    data: z.ZodAny;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"MUTATE">;
-    resource: z.ZodString;
-    resourceId: z.ZodOptional<z.ZodString>;
-    procedure: z.ZodEnum<{
-        INSERT: "INSERT";
-        UPDATE: "UPDATE";
-    }>;
-    payload: z.ZodRecord<z.ZodString, z.ZodObject<{
-        value: z.ZodNullable<z.ZodAny>;
-        _meta: z.ZodOptional<z.ZodObject<{
-            timestamp: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    id: z.ZodString;
-}, z.core.$strip>]>;
-type ServerMessage = z.infer<typeof serverMessageSchema>;
-
-type WebSocketClientEventMap = WebSocketEventMap & {
-    connectionChange: {
-        open: boolean;
-    };
-};
-declare class WebSocketClient {
-    private ws;
-    private url;
-    private autoConnect;
-    private autoReconnect;
-    private reconnectTimeout;
-    private reconnectLimit?;
-    private reconnectAttempts;
-    private eventListeners;
-    private reconnectTimer;
-    private intentionallyDisconnected;
-    private credentials?;
-    constructor(options: {
-        url: string;
-        autoConnect?: boolean;
-        autoReconnect?: boolean;
-        reconnectTimeout?: number;
-        reconnectLimit?: number;
-        credentials?: ClientOptions["credentials"];
-    });
-    connected(): boolean;
-    connect(): Promise<void>;
-    disconnect(): void;
-    addEventListener<K extends keyof WebSocketClientEventMap>(event: K, callback: (event: WebSocketClientEventMap[K]) => void): void;
-    removeEventListener<K extends keyof WebSocketClientEventMap>(event: K, callback: (event: WebSocketClientEventMap[K]) => void): void;
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-    private handleOpen;
-    private handleClose;
-    private handleError;
-    private handleMessage;
-    private scheduleReconnect;
-    private dispatchEvent;
-}
-
-interface WebSocketClientOptions extends ClientOptions {
-    connection?: {
-        autoConnect?: boolean;
-        autoReconnect?: boolean;
-        reconnectTimeout?: number;
-        maxReconnectAttempts?: number;
-    };
-}
-type ConnectionStateChangeEvent = {
-    type: "CONNECTION_STATE_CHANGE";
-    open: boolean;
-};
-type MessageReceivedEvent = {
-    type: "MESSAGE_RECEIVED";
-    message: ServerMessage;
-};
-type ClientStorageLoadedEvent = {
-    type: "CLIENT_STORAGE_LOADED";
-    resource: string;
-    itemCount: number;
-};
-type DataLoadRequestedEvent = {
-    type: "DATA_LOAD_REQUESTED";
-    query: RawQueryRequest;
-    subscriptionId: string;
-};
-type DataLoadReplyEvent = {
-    type: "DATA_LOAD_REPLY";
-    resource: string;
-    itemCount: number;
-    subscriptionId?: string;
-};
-type MutationSentEvent = {
-    type: "MUTATION_SENT";
-    mutationId: string;
-    resource: string;
-    resourceId: string;
-    procedure: string;
-    optimistic: boolean;
-};
-type MutationReceivedEvent = {
-    type: "MUTATION_RECEIVED";
-    mutationId: string;
-    resource: string;
-    resourceId: string;
-    procedure: string;
-};
-type MutationRejectedEvent = {
-    type: "MUTATION_REJECTED";
-    mutationId: string;
-    resource: string;
-};
-type SubscriptionCreatedEvent = {
-    type: "SUBSCRIPTION_CREATED";
-    query: RawQueryRequest;
-    subscriptionKey: string;
-    subscriberCount: number;
-};
-type SubscriptionRemovedEvent = {
-    type: "SUBSCRIPTION_REMOVED";
-    query: RawQueryRequest;
-    subscriptionKey: string;
-};
-type QueryExecutedEvent = {
-    type: "QUERY_EXECUTED";
-    query: RawQueryRequest;
-    resultCount: number;
-};
-type QuerySubscriptionTriggeredEvent = {
-    type: "QUERY_SUBSCRIPTION_TRIGGERED";
-    query: RawQueryRequest;
-};
-type StoreStateUpdatedEvent = {
-    type: "STORE_STATE_UPDATED";
-    resource: string;
-    itemCount: number;
-};
-type OptimisticMutationAppliedEvent = {
-    type: "OPTIMISTIC_MUTATION_APPLIED";
-    mutationId: string;
-    resource: string;
-    resourceId: string;
-    procedure: string;
-    pendingMutations: number;
-};
-type OptimisticMutationUndoneEvent = {
-    type: "OPTIMISTIC_MUTATION_UNDONE";
-    mutationId: string;
-    resource: string;
-    resourceId: string;
-    pendingMutations: number;
-};
-type ClientEvents = ConnectionStateChangeEvent | MessageReceivedEvent | ClientStorageLoadedEvent | DataLoadRequestedEvent | DataLoadReplyEvent | MutationSentEvent | MutationReceivedEvent | MutationRejectedEvent | SubscriptionCreatedEvent | SubscriptionRemovedEvent | QueryExecutedEvent | QuerySubscriptionTriggeredEvent | StoreStateUpdatedEvent | OptimisticMutationAppliedEvent | OptimisticMutationUndoneEvent;
-type Client<TRouter extends ClientRouterConstraint> = {
-    client: {
-        ws: WebSocketClient;
-        addEventListener: (listener: (event: ClientEvents) => void) => () => void;
-        load: (query: RawQueryRequest) => () => void;
-    };
-    store: Client$1<TRouter>;
-};
-declare const createClient: <TRouter extends ClientRouterConstraint>(opts: WebSocketClientOptions) => Client<TRouter>;
-
-type ClientOptions = {
-    url: string;
-    schema: Schema<any>;
-    credentials?: Generatable<PromiseOrSync<Record<string, string>>>;
-    storage: {
-        name: string;
-    } | false;
-    logLevel?: LogLevel;
-};
-
-export { type ClientOptions as C, type DataLoadRequestedEvent as D, type MessageReceivedEvent as M, type OptimisticMutationAppliedEvent as O, type QueryExecutedEvent as Q, type SubscriptionCreatedEvent as S, type ClientRouterConstraint as a, type Client$1 as b, useLoadData as c, type ConnectionStateChangeEvent as d, type ClientStorageLoadedEvent as e, type DataLoadReplyEvent as f, type MutationSentEvent as g, type MutationReceivedEvent as h, type MutationRejectedEvent as i, type SubscriptionRemovedEvent as j, type QuerySubscriptionTriggeredEvent as k, type StoreStateUpdatedEvent as l, type OptimisticMutationUndoneEvent as m, type ClientEvents as n, type Client as o, createClient as p, useLiveQuery as u };