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

package/dist/index-CLkafi56.d.ts

@@ -0,0 +1,1016 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { z } from 'zod';
+
+/** biome-ignore-all lint/complexity/noBannedTypes: false positive */
+/**
+ * Base metadata type for live types.
+ * All metadata types must extend this base.
+ */
+type BaseMeta = {};
+/**
+ * Metadata type for atomic live types with timestamp for LWW conflict resolution.
+ */
+type AtomicMeta = {
+    timestamp: string | null;
+} & BaseMeta;
+type MutationType = "set";
+/**
+ * Describes the storage field type for database mapping.
+ */
+type StorageFieldType = {
+    type: string;
+    nullable: boolean;
+    default?: any;
+    unique?: boolean;
+    index?: boolean;
+    primary?: boolean;
+    references?: string;
+    enumValues?: readonly string[];
+    enumName?: string;
+};
+/**
+ * Materialized representation of a LiveType value with metadata.
+ * Used internally for storage and sync operations.
+ */
+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"];
+};
+/**
+ * Abstract base class for all live types.
+ *
+ * @template Value - The actual TypeScript value type
+ * @template Meta - Metadata type for sync resolution (defaults to BaseMeta)
+ * @template EncodeInput - Type accepted during mutations
+ * @template DecodeInput - Type returned after encoding
+ */
+declare abstract class LiveType<Value = any, Meta extends BaseMeta = BaseMeta, 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, BaseMeta, any, any>;
+/**
+ * Extracts the TypeScript value type from a LiveType.
+ */
+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;
+
+/**
+ * Helper type to extract Value type from LiveAtomicType
+ */
+type ExtractValue<T> = T extends LiveAtomicType<infer V, any, any> ? V : never;
+/**
+ * Helper type to extract Meta type from LiveAtomicType
+ */
+type ExtractMeta<T> = T extends LiveAtomicType<any, any, infer M> ? M : AtomicMeta;
+/**
+ * Wraps a LiveAtomicType to allow null values.
+ * Supports chainable modifiers like `.default()`, `.unique()`, `.index()`, `.primary()`.
+ */
+declare class NullableLiveType<T extends LiveAtomicType<any, any, any>> extends LiveType<T["_value"] | null, T["_meta"], T["_encodeInput"] | null, 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;
+    /**
+     * Returns a new nullable type with a unique constraint.
+     */
+    unique(): NullableLiveType<LiveAtomicType<ExtractValue<T>, undefined, ExtractMeta<T>>>;
+    /**
+     * Returns a new nullable type with an index.
+     */
+    index(): NullableLiveType<LiveAtomicType<ExtractValue<T>, undefined, ExtractMeta<T>>>;
+    /**
+     * Returns a new nullable type with a default value.
+     * Can be the value type or null.
+     */
+    default(value: ExtractValue<T> | null): NullableLiveType<LiveAtomicType<ExtractValue<T>, ExtractValue<T> | null, ExtractMeta<T>>>;
+    /**
+     * Returns a new nullable type marked as primary key.
+     */
+    primary(): NullableLiveType<LiveAtomicType<ExtractValue<T>, undefined, ExtractMeta<T>>>;
+}
+/**
+ * Base class for atomic (scalar) live types.
+ *
+ * @template Value - The value type (string, number, boolean, Date)
+ * @template DefaultValue - The default value type (undefined if no default)
+ * @template Meta - Metadata type for sync resolution
+ */
+declare class LiveAtomicType<Value, DefaultValue = undefined, Meta extends AtomicMeta = AtomicMeta> extends LiveType<Value, Meta, Value, {
+    value: Value;
+    _meta: Meta;
+}> {
+    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: Meta;
+    };
+    mergeMutation(mutationType: MutationType, encodedMutation: {
+        value: Value;
+        _meta: Meta;
+    }, materializedShape?: MaterializedLiveType<LiveType<Value, Meta, Value | Partial<Value>, {
+        value: Value;
+        _meta: Meta;
+    }>>): [
+        MaterializedLiveType<LiveType<Value, Meta, Value | Partial<Value>, {
+            value: Value;
+            _meta: Meta;
+        }>>,
+        {
+            value: Value;
+            _meta: Meta;
+        } | null
+    ];
+    getStorageFieldType(): StorageFieldType;
+    /**
+     * Returns a new atomic type with a unique constraint.
+     */
+    unique(): LiveAtomicType<Value, undefined, Meta>;
+    /**
+     * Returns a new atomic type with an index.
+     */
+    index(): LiveAtomicType<Value, undefined, Meta>;
+    /**
+     * Returns a new atomic type with a default value.
+     */
+    default(value: Value): LiveAtomicType<Value, Value, Meta>;
+    /**
+     * Returns a new atomic type marked as primary key.
+     */
+    primary(): LiveAtomicType<Value, undefined, Meta>;
+    /**
+     * Returns a nullable version of this type.
+     * If no default value was set, defaults to null.
+     */
+    nullable(): NullableLiveType<LiveAtomicType<Value, DefaultValue extends undefined ? null : DefaultValue, Meta>>;
+    /**
+     * Returns a new atomic type with custom metadata type for advanced sync strategies.
+     *
+     * @example
+     * ```ts
+     * type VectorClockMeta = AtomicMeta & { vectorClock: Record<string, number> };
+     * const content = string().withMeta<VectorClockMeta>();
+     * ```
+     */
+    withMeta<TMeta extends AtomicMeta>(): LiveAtomicType<Value, DefaultValue, TMeta>;
+}
+/**
+ * Live string type.
+ */
+declare class LiveString extends LiveAtomicType<string> {
+    private constructor();
+    static create(): LiveString;
+    static createId(): LiveAtomicType<string, undefined, {
+        timestamp: string | null;
+    }>;
+    static createReference(foreignField: `${string}.${string}`): LiveString;
+}
+
+/**
+ * Forward declaration for LiveCollection to avoid circular dependency.
+ * The actual type is defined in collection.ts
+ */
+interface LiveCollectionAny$1 {
+    readonly name: string;
+    readonly fields: Record<string, LiveTypeAny>;
+    readonly relations: Record<string, RelationAny>;
+    setRelations<TRelations extends Record<string, RelationAny>>(relations: TRelations): LiveCollectionAny$1;
+}
+/**
+ * Represents a relation between two collections.
+ *
+ * @template TEntity - The target collection
+ * @template TSourceEntity - The source collection
+ * @template TType - "one" for many-to-one, "many" for one-to-many
+ * @template TRelationalColumn - The FK column on source (for "one" relations)
+ * @template TForeignColumn - The FK column on target (for "many" relations)
+ * @template TRequired - Whether the relation is required
+ */
+declare class Relation<TEntity extends LiveCollectionAny$1, TSourceEntity extends LiveCollectionAny$1, TType extends "one" | "many", TRelationalColumn extends keyof TSourceEntity["fields"], TForeignColumn extends keyof TEntity["fields"], TRequired extends boolean> extends LiveType<InferIndex<TEntity extends LiveTypeAny ? TEntity : LiveTypeAny>, {
+    timestamp: string | null;
+} & BaseMeta> {
+    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;
+    };
+    /**
+     * Creates a factory for many-to-one relations.
+     */
+    static createOneFactory<TOriginEntity extends LiveCollectionAny$1>(): <TEntity extends LiveCollectionAny$1, TColumn extends keyof TOriginEntity["fields"], TRequired extends boolean = false>(entity: TEntity, column: TColumn, required?: TRequired) => Relation<TEntity, TOriginEntity, "one", TColumn, never, TRequired>;
+    /**
+     * Creates a factory for one-to-many relations.
+     */
+    static createManyFactory<TOriginEntity extends LiveCollectionAny$1>(): <TEntity extends LiveCollectionAny$1, 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<LiveCollectionAny$1, LiveCollectionAny$1, any, any, any, any>;
+/**
+ * Connectors for defining relations.
+ */
+type RelationConnectors<TSourceEntity extends LiveCollectionAny$1> = {
+    one: ReturnType<typeof Relation.createOneFactory<TSourceEntity>>;
+    many: ReturnType<typeof Relation.createManyFactory<TSourceEntity>>;
+};
+/**
+ * Declaration type for relations defined separately from collections.
+ */
+type RelationsDecl<TCollectionName extends string = string, TRelations extends Record<string, RelationAny> = Record<string, RelationAny>> = {
+    $type: "relations";
+    collectionName: TCollectionName;
+    /** @deprecated Use `collectionName` instead */
+    objectName: TCollectionName;
+    relations: TRelations;
+};
+
+/**
+ * Mutation input type for collections.
+ */
+type LiveCollectionMutationInput<TSchema extends LiveCollectionAny> = Partial<{
+    [K in keyof TSchema["fields"]]: TSchema["fields"][K]["_value"];
+}>;
+/**
+ * Configuration object for creating a collection with inline relations.
+ */
+type CollectionConfig<TName extends string, TFields extends Record<string, LiveTypeAny>, TRelations extends Record<string, RelationAny> = Record<string, never>> = {
+    fields: TFields;
+    relations?: (connectors: RelationConnectors<LiveCollection<TName, TFields, any>>) => TRelations;
+};
+/**
+ * Represents a collection of entities with fields and relations.
+ *
+ * @template TName - The collection name (used as resource identifier)
+ * @template TFields - The field schema
+ * @template TRelations - The relations schema
+ */
+declare class LiveCollection<TName extends string, TFields extends Record<string, LiveTypeAny>, TRelations extends Record<string, RelationAny>> extends LiveType<TFields, BaseMeta, LiveCollectionMutationInput<any>, Record<string, MaterializedLiveType<LiveTypeAny>>> {
+    readonly name: TName;
+    readonly fields: TFields;
+    readonly relations: TRelations;
+    constructor(name: TName, fields: TFields, relations?: TRelations);
+    encodeMutation(_mutationType: MutationType, input: LiveCollectionMutationInput<this>, timestamp: string): Record<string, any>;
+    mergeMutation(mutationType: MutationType, encodedMutations: Record<string, MaterializedLiveType<LiveTypeAny>>, materializedShape?: MaterializedLiveType<this> | undefined): [MaterializedLiveType<this>, Record<string, any> | null];
+    /**
+     * Returns a new collection with the given relations attached.
+     */
+    setRelations<TNewRelations extends Record<string, RelationAny>>(relations: TNewRelations): LiveCollection<this["name"], this["fields"], TNewRelations>;
+    getStorageFieldType(): StorageFieldType;
+    /**
+     * Creates a new collection with fields only.
+     */
+    static create<TName extends string, TFields extends Record<string, LiveTypeAny>>(name: TName, fields: TFields): LiveCollection<TName, TFields, Record<string, never>>;
+    /**
+     * Creates a new collection with fields and inline relations.
+     */
+    static create<TName extends string, TFields extends Record<string, LiveTypeAny>, TRelations extends Record<string, RelationAny>>(name: TName, config: CollectionConfig<TName, TFields, TRelations>): LiveCollection<TName, TFields, TRelations>;
+}
+type LiveCollectionAny = LiveCollection<string, Record<string, LiveTypeAny>, any>;
+/** @deprecated Use `LiveCollectionAny` instead */
+type LiveObjectAny = LiveCollectionAny;
+
+/** biome-ignore-all lint/complexity/noBannedTypes: false positive */
+
+/**
+ * Where clause for filtering collections.
+ * Supports field comparisons, operators, and nested relation queries.
+ */
+type WhereClause<T extends LiveCollectionAny> = ({
+    [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>[];
+};
+/**
+ * Sub-query options for nested includes.
+ * Allows filtering, sorting, and pagination of related collections.
+ */
+type SubQueryInclude<T extends LiveCollectionAny> = {
+    where?: WhereClause<T>;
+    limit?: number;
+    orderBy?: {
+        key: keyof T["fields"] & string;
+        direction: "asc" | "desc";
+    }[];
+    include?: IncludeClause<T>;
+};
+/**
+ * Include clause for specifying which relations to fetch.
+ * Can be a boolean or a sub-query for fine-grained control.
+ */
+type IncludeClause<T extends LiveCollectionAny> = {
+    [K in keyof T["relations"]]?: boolean | SubQueryInclude<T["relations"][K]["entity"]>;
+};
+
+type Simplify<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : 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];
+/**
+ * Logger configuration options
+ */
+interface LoggerOptions {
+    /**
+     * Minimum log level to display. Anything below this level will be muted.
+     * @default LogLevel.INFO
+     */
+    level?: LogLevel;
+    /**
+     * Optional prefix to add to all log messages
+     */
+    prefix?: string;
+}
+declare class Logger {
+    private level;
+    private prefix;
+    constructor(options?: LoggerOptions);
+    critical(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}
+
+/**
+ * Infers the TypeScript type of a collection without relations.
+ */
+type InferLiveCollectionWithoutRelations<T extends LiveCollectionAny> = {
+    [K in keyof T["fields"]]: InferLiveType<T["fields"][K]>;
+};
+/**
+ * Infers the full TypeScript type of a collection with optional relations.
+ *
+ * @template T - The collection type
+ * @template Include - The include clause specifying which relations to include
+ */
+type InferLiveCollection<T extends LiveCollectionAny, Include extends IncludeClause<T> | undefined = undefined> = Simplify<InferLiveCollectionWithoutRelations<T> & (Include extends IncludeClause<T> ? {
+    [K in keyof T["relations"] as Include[K] extends true | SubQueryInclude<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> ? InferLiveCollection<T["relations"][K]["entity"]> | null : InferLiveCollection<T["relations"][K]["entity"]> : InferLiveCollection<T["relations"][K]["entity"]>[] : Include[K] extends SubQueryInclude<T["relations"][K]["entity"]> ? T["relations"][K]["type"] extends "one" ? T["fields"][Exclude<T["relations"][K]["relationalColumn"], undefined>] extends NullableLiveType<any> ? InferLiveCollection<T["relations"][K]["entity"], Include[K]["include"]> | null : InferLiveCollection<T["relations"][K]["entity"], Include[K]["include"]> : InferLiveCollection<T["relations"][K]["entity"], Include[K]["include"]>[] : never;
+} : object)>;
+type GetFieldType<T> = T extends NullableLiveType<any> ? T["inner"] : T;
+type HasDefaultValue<T> = T extends {
+    defaultValue: undefined;
+} ? false : true;
+/**
+ * Infers the insert type for a collection.
+ * Fields without defaults are required, fields with defaults are optional.
+ */
+type InferInsert<T extends LiveCollectionAny> = Simplify<{
+    [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]>;
+}>;
+/**
+ * Infers the update type for a collection.
+ * All fields are optional except id which is excluded.
+ */
+type InferUpdate<T extends LiveCollectionAny> = Simplify<Omit<LiveCollectionMutationInput<T>, "id">>;
+/** @deprecated Use `InferLiveCollection` instead */
+type InferLiveObject<T extends LiveCollectionAny, Include extends IncludeClause<T> | undefined = undefined> = InferLiveCollection<T, Include>;
+
+type ExtractObjectValues<T> = T[keyof T];
+type ParseRelationsFromSchema<TRawSchema extends RawSchema, TCollectionName extends string> = ExtractObjectValues<{
+    [K in keyof TRawSchema]: TRawSchema[K] extends RelationsDecl<infer TCollectionName_, any> ? TCollectionName_ extends TCollectionName ? {
+        [K2 in keyof TRawSchema[K]["relations"]]: Relation<ParseCollectionFromSchema<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 ParseCollectionFromSchema<TRawSchema extends RawSchema, TCollectionName extends string> = ExtractObjectValues<{
+    [K in keyof TRawSchema]: TRawSchema[K] extends LiveCollectionAny ? TRawSchema[K]["name"] extends TCollectionName ? LiveCollection<TRawSchema[K]["name"], TRawSchema[K]["fields"], ParseRelationsFromSchema<TRawSchema, TRawSchema[K]["name"]>> : never : never;
+}>;
+type RawSchema = Record<string, LiveCollectionAny | RelationsDecl>;
+/**
+ * The final schema type with all collections and their relations resolved.
+ */
+type Schema<TRawSchema extends RawSchema> = {
+    [K in keyof TRawSchema as TRawSchema[K] extends LiveCollectionAny ? TRawSchema[K]["name"] : never]: TRawSchema[K] extends LiveCollectionAny ? ParseCollectionFromSchema<TRawSchema, TRawSchema[K]["name"]> : never;
+};
+
+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);
+
+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>;
+declare const customQuerySchema: z.ZodObject<{
+    resource: z.ZodString;
+    procedure: z.ZodString;
+    input: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+type CustomQueryRequest = z.infer<typeof customQuerySchema>;
+
+/** 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$1<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>;
+/**
+ * Helper type for custom query functions.
+ * When the input type is `never` or `undefined`, the function has no parameters.
+ */
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+type CustomQueryLoadable<TOutput> = PromiseLike<TOutput> & {
+    buildQueryRequest: () => CustomQueryRequest;
+};
+type CustomQueryResult<TOutput, TShouldAwait extends boolean = false> = UnwrapPromise<TOutput> extends QueryBuilder<infer TCollection, infer TInclude, infer TSingle, any> ? TShouldAwait extends true ? TSingle extends true ? Promise<Simplify<InferLiveObject<TCollection, TInclude>> | undefined> : Promise<Simplify<InferLiveObject<TCollection, TInclude>>[]> : TSingle extends true ? CustomQueryLoadable<Simplify<InferLiveObject<TCollection, TInclude>> | undefined> : CustomQueryLoadable<Simplify<InferLiveObject<TCollection, TInclude>>[]> : Promisify<UnwrapPromise<TOutput>>;
+type CustomQueryFunction<TInput, TOutput, TShouldAwait extends boolean = false> = [TInput] extends [never] | [undefined] ? () => CustomQueryResult<TOutput, TShouldAwait> : (input: TInput) => CustomQueryResult<TOutput, TShouldAwait>;
+/**
+ * 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 | undefined;
+        customMutations: Record<string, {
+            _type: "mutation";
+            inputValidator: StandardSchemaV1<any, any>;
+            handler: (...args: any[]) => any;
+        }>;
+        customQueries: Record<string, {
+            _type: "query";
+            inputValidator: StandardSchemaV1<any, any>;
+            handler: (...args: any[]) => any;
+        }>;
+    }>;
+};
+type CollectionQueryType<TRoute extends ClientRouterConstraint["routes"][string], TShouldAwait extends boolean> = TRoute["resourceSchema"] extends LiveObjectAny ? QueryBuilder<TRoute["resourceSchema"], {}, false, TShouldAwait> & {
+    [K2 in keyof TRoute["customQueries"]]: CustomQueryFunction<InferSchema$1<TRoute["customQueries"][K2]["inputValidator"]>, ReturnType<TRoute["customQueries"][K2]["handler"]>, TShouldAwait>;
+} : {
+    [K2 in keyof TRoute["customQueries"]]: CustomQueryFunction<InferSchema$1<TRoute["customQueries"][K2]["inputValidator"]>, ReturnType<TRoute["customQueries"][K2]["handler"]>, TShouldAwait>;
+};
+type CollectionMutateType<TRoute extends ClientRouterConstraint["routes"][string], TShouldAwait extends boolean> = TRoute["resourceSchema"] extends LiveObjectAny ? {
+    insert: (input: Simplify<InferInsert<TRoute["resourceSchema"]>>) => ConditionalPromise<void, TShouldAwait>;
+    update: (id: string, value: Simplify<InferUpdate<TRoute["resourceSchema"]>>) => ConditionalPromise<void, TShouldAwait>;
+} & {
+    [K2 in keyof TRoute["customMutations"]]: CustomMutationFunction<InferSchema$1<TRoute["customMutations"][K2]["inputValidator"]>, ReturnType<TRoute["customMutations"][K2]["handler"]>>;
+} : {
+    [K2 in keyof TRoute["customMutations"]]: CustomMutationFunction<InferSchema$1<TRoute["customMutations"][K2]["inputValidator"]>, ReturnType<TRoute["customMutations"][K2]["handler"]>>;
+};
+type Client$1<TRouter extends ClientRouterConstraint, TShouldAwait extends boolean = false> = {
+    query: {
+        [K in keyof TRouter["routes"]]: CollectionQueryType<TRouter["routes"][K], TShouldAwait>;
+    };
+    mutate: {
+        [K in keyof TRouter["routes"]]: CollectionMutateType<TRouter["routes"][K], TShouldAwait>;
+    };
+};
+
+/**
+ * Extracts the output type from a Standard Schema validator.
+ */
+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;
+/**
+ * Operation types for optimistic mutations.
+ */
+type OptimisticInsertOperation<T extends LiveCollectionAny> = {
+    type: "insert";
+    resource: string;
+    id: string;
+    data: Simplify<InferInsert<T>>;
+};
+type OptimisticUpdateOperation<T extends LiveCollectionAny> = {
+    type: "update";
+    resource: string;
+    id: string;
+    data: Simplify<InferUpdate<T>>;
+};
+type OptimisticOperation<T extends LiveCollectionAny = LiveCollectionAny> = OptimisticInsertOperation<T> | OptimisticUpdateOperation<T>;
+/**
+ * Query builder type for the storage proxy (read-only operations).
+ */
+type OptimisticQueryBuilder<T extends LiveCollectionAny> = {
+    one: (id: string) => {
+        get: () => Simplify<InferLiveCollection<T>> | undefined;
+        include: <TInclude extends Record<string, boolean | object>>(include: TInclude) => {
+            get: () => Simplify<InferLiveCollection<T, TInclude>> | undefined;
+        };
+    };
+    where: (where: Record<string, unknown>) => {
+        get: () => Simplify<InferLiveCollection<T>>[];
+        include: <TInclude extends Record<string, boolean | object>>(include: TInclude) => {
+            get: () => Simplify<InferLiveCollection<T, TInclude>>[];
+        };
+    };
+    get: () => Simplify<InferLiveCollection<T>>[];
+    include: <TInclude extends Record<string, boolean | object>>(include: TInclude) => {
+        get: () => Simplify<InferLiveCollection<T, TInclude>>[];
+    };
+};
+/**
+ * Mutation methods for the storage proxy (write operations).
+ */
+type OptimisticMutationMethods<T extends LiveCollectionAny> = {
+    insert: (data: Simplify<InferInsert<T>> & {
+        id: string;
+    }) => void;
+    update: (id: string, data: Simplify<InferUpdate<T>>) => void;
+};
+/**
+ * Combined storage proxy type with both query and mutation capabilities.
+ */
+type OptimisticStorageProxy<TSchema extends Schema<any>> = {
+    [K in keyof TSchema]: OptimisticQueryBuilder<TSchema[K]> & OptimisticMutationMethods<TSchema[K]>;
+};
+/**
+ * Context passed to optimistic mutation handlers.
+ */
+type OptimisticHandlerContext<TSchema extends Schema<any>, TInput> = {
+    input: TInput;
+    storage: OptimisticStorageProxy<TSchema>;
+};
+/**
+ * Type for a single optimistic mutation handler.
+ */
+type OptimisticMutationHandler<TSchema extends Schema<any>, TInput> = (ctx: OptimisticHandlerContext<TSchema, TInput>) => void;
+/**
+ * Configuration type for defineOptimisticMutations.
+ * Maps route names to procedure names to handlers.
+ */
+type OptimisticMutationsConfig<TRouter extends ClientRouterConstraint, TSchema extends Schema<any>> = {
+    [K in keyof TRouter["routes"]]?: {
+        [K2 in keyof TRouter["routes"][K]["customMutations"]]?: OptimisticMutationHandler<TSchema, InferSchema<TRouter["routes"][K]["customMutations"][K2]["inputValidator"]>>;
+    };
+};
+/**
+ * Registry type returned by defineOptimisticMutations.
+ * Used internally to look up handlers by route and procedure.
+ */
+type OptimisticMutationsRegistry<TSchema extends Schema<any>> = {
+    getHandler: (route: string, procedure: string) => OptimisticMutationHandler<TSchema, any> | undefined;
+};
+
+declare const defaultMutationMsgSchema: 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>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+type DefaultMutationMessage = Omit<z.infer<typeof defaultMutationMsgSchema>, 'resourceId'> & {
+    resourceId: string;
+};
+declare const mutationMsgSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"MUTATE">;
+    resource: z.ZodString;
+    resourceId: z.ZodOptional<z.ZodString>;
+    procedure: z.ZodString;
+    payload: z.ZodOptional<z.ZodAny>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+}, 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>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+}, z.core.$strip>]>;
+type MutationMessage = z.infer<typeof mutationMsgSchema>;
+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>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+}, z.core.$strip>]>;
+type ServerMessage = z.infer<typeof serverMessageSchema>;
+
+declare class OptimisticStore {
+    readonly schema: Schema<any>;
+    private rawObjPool;
+    optimisticMutationStack: Record<string, DefaultMutationMessage[]>;
+    customMutationStack: MutationMessage[];
+    private optimisticObjGraph;
+    private optimisticRawObjPool;
+    private logger;
+    private onQuerySubscriptionTriggered?;
+    customMutationIndex: Record<string, Array<{
+        resource: string;
+        mutationId: string;
+    }>>;
+    private collectionSubscriptions;
+    private querySnapshots;
+    private kvStorage;
+    constructor(schema: Schema<any>, storage: ClientOptions["storage"], logger: Logger, afterLoadMutations?: (stack: typeof this.optimisticMutationStack, customStack: MutationMessage[], customIndex: typeof this.customMutationIndex) => void, onStorageLoaded?: (resource: string, itemCount: number) => void, onQuerySubscriptionTriggered?: (query: RawQueryRequest) => void);
+    get(query: RawQueryRequest, _queryKey?: string, force?: boolean): any;
+    subscribe(query: RawQueryRequest, listener: (v: any[]) => void): () => void;
+    addMutation(routeName: string, mutation: DefaultMutationMessage, optimistic?: boolean): void;
+    undoMutation(routeName: string, mutationId: string): void;
+    addCustomMutationMessage(message: MutationMessage): void;
+    registerCustomMutation(messageId: string, mutations: Array<{
+        resource: string;
+        mutationId: string;
+    }>): void;
+    confirmCustomMutation(messageId: string): void;
+    undoCustomMutation(messageId: string): Array<{
+        resource: string;
+        mutationId: string;
+        resourceId: string;
+    }>;
+    getCustomMutationMutationIds(): Set<string>;
+    loadConsolidatedState(resourceType: string, data: DefaultMutationMessage["payload"][]): void;
+    private extractNestedRelations;
+    private updateRawObjPool;
+    private materializeOneWithInclude;
+    private notifyCollectionSubscribers;
+    private flattenIncludes;
+}
+
+/**
+ * Creates an optimistic storage proxy that:
+ * - Provides synchronous read access to the optimistic state via QueryBuilder-like methods
+ * - Collects insert/update operations in an internal array
+ * - Returns collected operations via getOperations()
+ */
+declare const createOptimisticStorageProxy: <TSchema extends Schema<any>>(store: OptimisticStore, schema: TSchema) => {
+    proxy: OptimisticStorageProxy<TSchema>;
+    getOperations: () => OptimisticOperation[];
+};
+
+/**
+ * Defines optimistic mutation handlers for custom mutations.
+ *
+ * These handlers are executed client-side before the mutation is sent to the server,
+ * allowing for instant UI updates. If the server rejects the mutation, the optimistic
+ * changes are automatically rolled back.
+ *
+ * @example
+ * ```ts
+ * const optimisticMutations = defineOptimisticMutations<typeof router, typeof schema>({
+ *   posts: {
+ *     like: ({ input, storage }) => {
+ *       const post = storage.posts.one(input.postId).get();
+ *       if (post) {
+ *         storage.posts.update(input.postId, { likes: post.likes + 1 });
+ *       }
+ *     },
+ *   },
+ * });
+ *
+ * const client = createClient({
+ *   url: 'ws://localhost:3000',
+ *   schema,
+ *   optimisticMutations,
+ * });
+ * ```
+ */
+declare const defineOptimisticMutations: <TRouter extends ClientRouterConstraint, TSchema extends Schema<any>>(config: OptimisticMutationsConfig<TRouter, TSchema>) => OptimisticMutationsRegistry<TSchema>;
+
+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: {
+    buildQueryRequest: () => RawQueryRequest | CustomQueryRequest;
+}) => void;
+
+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<TSchema extends Schema<any> = Schema<any>> extends ClientOptions<TSchema> {
+    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 | CustomQueryRequest;
+    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 | CustomQueryRequest;
+    subscriptionKey: string;
+    subscriberCount: number;
+};
+type SubscriptionRemovedEvent = {
+    type: "SUBSCRIPTION_REMOVED";
+    query: RawQueryRequest | CustomQueryRequest;
+    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 | CustomQueryRequest) => () => void;
+    };
+    store: Client$1<TRouter>;
+};
+declare const createClient: <TRouter extends ClientRouterConstraint>(opts: WebSocketClientOptions) => Client<TRouter>;
+
+type ClientOptions<TSchema extends Schema<any> = Schema<any>> = {
+    url: string;
+    schema: TSchema;
+    credentials?: Generatable<PromiseOrSync<Record<string, string>>>;
+    storage: {
+        name: string;
+    } | false;
+    logLevel?: LogLevel;
+    optimisticMutations?: OptimisticMutationsRegistry<TSchema>;
+};
+
+export { createClient as A, type ClientOptions as C, type DataLoadRequestedEvent as D, type MessageReceivedEvent as M, type OptimisticMutationsConfig as O, type QueryExecutedEvent as Q, type SubscriptionCreatedEvent as S, type ClientRouterConstraint as a, type Client$1 as b, type OptimisticMutationsRegistry as c, defineOptimisticMutations as d, type OptimisticHandlerContext as e, type OptimisticStorageProxy as f, type OptimisticOperation as g, type OptimisticInsertOperation as h, type OptimisticUpdateOperation as i, type OptimisticMutationHandler as j, createOptimisticStorageProxy as k, useLoadData as l, type ConnectionStateChangeEvent as m, type ClientStorageLoadedEvent as n, type DataLoadReplyEvent as o, type MutationSentEvent as p, type MutationReceivedEvent as q, type MutationRejectedEvent as r, type SubscriptionRemovedEvent as s, type QuerySubscriptionTriggeredEvent as t, useLiveQuery as u, type StoreStateUpdatedEvent as v, type OptimisticMutationAppliedEvent as w, type OptimisticMutationUndoneEvent as x, type ClientEvents as y, type Client as z };