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

package/dist/index-hO1iQ-VU.d.ts

@@ -0,0 +1,608 @@
+/** 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;
+/** @deprecated Use `BaseMeta` instead */
+type LiveTypeMeta = BaseMeta;
+
+/**
+ * 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 number type.
+ */
+declare class LiveNumber extends LiveAtomicType<number> {
+    private constructor();
+    static create(): LiveNumber;
+}
+declare const number: typeof LiveNumber.create;
+/**
+ * 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;
+}
+declare const string: typeof LiveString.create;
+declare const id: typeof LiveString.createId;
+declare const reference: typeof LiveString.createReference;
+/**
+ * Live boolean type.
+ */
+declare class LiveBoolean extends LiveAtomicType<boolean> {
+    private constructor();
+    static create(): LiveBoolean;
+}
+declare const boolean: typeof LiveBoolean.create;
+/**
+ * Live timestamp type (maps to Date).
+ */
+declare class LiveTimestamp extends LiveAtomicType<Date> {
+    private constructor();
+    static create(): LiveTimestamp;
+}
+declare const timestamp: typeof LiveTimestamp.create;
+/**
+ * Live enum type.
+ * Maps to native enum in Postgres, varchar in MySQL/SQLite.
+ */
+declare class LiveEnum<Value extends string, DefaultValue = undefined, Meta extends AtomicMeta = AtomicMeta> extends LiveAtomicType<Value, DefaultValue, Meta> {
+    readonly enumValues: readonly Value[];
+    readonly enumName: string;
+    constructor(values: readonly Value[], index?: boolean, unique?: boolean, defaultValue?: DefaultValue, primary?: boolean);
+    getStorageFieldType(): StorageFieldType;
+    unique(): LiveEnum<Value, undefined, Meta>;
+    index(): LiveEnum<Value, undefined, Meta>;
+    default(value: Value): LiveEnum<Value, Value, Meta>;
+    primary(): LiveEnum<Value, undefined, Meta>;
+    nullable(): NullableLiveType<LiveEnum<Value, DefaultValue extends undefined ? null : DefaultValue, Meta>>;
+    static create<const T extends readonly string[]>(values: T): LiveEnum<T[number]>;
+}
+declare const enumType: typeof LiveEnum.create;
+/**
+ * Live JSON type.
+ * Maps to jsonb in Postgres, json in MySQL, text in SQLite.
+ */
+declare class LiveJson<Value, DefaultValue = undefined, Meta extends AtomicMeta = AtomicMeta> extends LiveAtomicType<Value, DefaultValue, Meta> {
+    constructor(index?: boolean, unique?: boolean, defaultValue?: DefaultValue, primary?: boolean);
+    getStorageFieldType(): StorageFieldType;
+    unique(): LiveJson<Value, undefined, Meta>;
+    index(): LiveJson<Value, undefined, Meta>;
+    default(value: Value): LiveJson<Value, Value, Meta>;
+    primary(): LiveJson<Value, undefined, Meta>;
+    nullable(): NullableLiveType<LiveJson<Value, DefaultValue extends undefined ? null : DefaultValue, Meta>>;
+    static create<T>(): LiveJson<T>;
+}
+declare const json: typeof LiveJson.create;
+
+/**
+ * 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;
+};
+/**
+ * Creates a relations declaration for a collection.
+ * Use this for circular dependencies or when defining relations separately.
+ *
+ * @example
+ * ```ts
+ * const userRelations = createRelations(users, ({ one, many }) => ({
+ *   posts: many(posts, 'authorId'),
+ *   profile: one(profile, 'profileId'),
+ * }));
+ * ```
+ */
+declare const createRelations: <TSourceCollection extends LiveCollectionAny$1, TRelations extends Record<string, RelationAny>>(collection: TSourceCollection, factory: (connectors: RelationConnectors<TSourceCollection>) => TRelations) => RelationsDecl<TSourceCollection["name"], 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>;
+}
+/**
+ * Creates a new collection.
+ *
+ * @example
+ * ```ts
+ * // Simple usage (fields only)
+ * const users = collection('users', {
+ *   id: id(),
+ *   name: string(),
+ * });
+ *
+ * // Full usage (fields + inline relations)
+ * const posts = collection('posts', {
+ *   fields: {
+ *     id: id(),
+ *     title: string(),
+ *     authorId: reference('users.id'),
+ *   },
+ *   relations: ({ one, many }) => ({
+ *     author: one(users, 'authorId'),
+ *     comments: many(comments, 'postId'),
+ *   }),
+ * });
+ * ```
+ */
+declare const collection: typeof LiveCollection.create;
+type LiveCollectionAny = LiveCollection<string, Record<string, LiveTypeAny>, any>;
+/** @deprecated Use `collection` instead */
+declare const object: typeof LiveCollection.create;
+/** @deprecated Use `LiveCollection` instead */
+declare const LiveObject: typeof LiveCollection;
+/** @deprecated Use `LiveCollectionAny` instead */
+type LiveObjectAny = LiveCollectionAny;
+/** @deprecated Use `LiveCollectionMutationInput` instead */
+type LiveObjectMutationInput<TSchema extends LiveCollectionAny> = LiveCollectionMutationInput<TSchema>;
+
+/** 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 relational columns (FK fields) from relations.
+ * Note: We use `string` directly since InferIndex currently returns string
+ * and RelationAny uses an interface that doesn't extend LiveTypeAny.
+ */
+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 ? string : string | null;
+};
+/**
+ * Infers the TypeScript type of a collection with relational IDs.
+ * Used for mutations where you need to set FK values.
+ */
+type InferLiveCollectionWithRelationalIds<T extends LiveCollectionAny> = keyof T["relations"] extends string ? InferLiveCollectionWithoutRelations<T> & InferRelationalColumns<T["relations"]> : InferLiveCollectionWithoutRelations<T>;
+/**
+ * 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">>;
+/**
+ * Extracts the value from a MaterializedLiveType at runtime.
+ */
+declare const inferValue: <T extends LiveTypeAny>(type?: MaterializedLiveType<T>) => InferLiveType<T> | undefined;
+/** @deprecated Use `InferLiveCollection` instead */
+type InferLiveObject<T extends LiveCollectionAny, Include extends IncludeClause<T> | undefined = undefined> = InferLiveCollection<T, Include>;
+/** @deprecated Use `InferLiveCollectionWithoutRelations` instead */
+type InferLiveObjectWithoutRelations<T extends LiveCollectionAny> = InferLiveCollectionWithoutRelations<T>;
+/** @deprecated Use `InferLiveCollectionWithRelationalIds` instead */
+type InferLiveObjectWithRelationalIds<T extends LiveCollectionAny> = InferLiveCollectionWithRelationalIds<T>;
+
+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;
+};
+/**
+ * Creates a schema from a raw schema object.
+ * Attaches relations to their corresponding collections.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({
+ *   users,
+ *   userRelations,
+ *   posts,
+ *   postRelations,
+ * });
+ * ```
+ */
+declare const createSchema: <TRawSchema extends RawSchema>(schema: TRawSchema) => Schema<TRawSchema>;
+
+export { inferValue as $, type AtomicMeta as A, type BaseMeta as B, timestamp as C, id as D, reference as E, enumType as F, json as G, createRelations as H, type IncludeClause as I, type RelationAny as J, type RelationConnectors as K, type LiveObjectAny as L, type MaterializedLiveType as M, NullableLiveType as N, type RelationsDecl as O, type LiveCollectionAny$1 as P, LiveCollection as Q, Relation as R, type Simplify as S, collection as T, type LiveCollectionMutationInput as U, type CollectionConfig as V, type WhereClause as W, object as X, LiveObject as Y, type LiveObjectMutationInput as Z, type SubQueryInclude as _, type InferLiveObject as a, type InferLiveCollectionWithoutRelations as a0, type InferLiveCollectionWithRelationalIds as a1, type InferLiveObjectWithoutRelations as a2, createSchema as a3, type InferInsert as b, type InferUpdate as c, type Schema as d, type LiveCollectionAny as e, type InferLiveCollection as f, type InferLiveObjectWithRelationalIds as g, Logger as h, LogLevel as i, LiveType as j, type LiveTypeAny as k, type MutationType as l, type StorageFieldType as m, type InferLiveType as n, type InferIndex as o, type LiveTypeMeta as p, LiveAtomicType as q, LiveNumber as r, LiveString as s, LiveBoolean as t, LiveTimestamp as u, LiveEnum as v, LiveJson as w, number as x, string as y, boolean as z };

package/dist/index.cjs

@@ -1 +1 @@
-'use strict';require('js-xxhash');var s=class{_value;_meta;_encodeInput;_decodeInput};var T=class extends s{inner;constructor(t){super(),this.inner=t;}encodeMutation(t,n,e){return this.inner.encodeMutation(t,n,e)}mergeMutation(t,n,e){return this.inner.mergeMutation(t,n,e)}getStorageFieldType(){return {...this.inner.getStorageFieldType(),nullable:true}}},l=class i extends s{storageType;convertFunc;isIndex;isUnique;defaultValue;foreignReference;isPrimary;constructor(t,n,e,a,r,u,y){super(),this.storageType=t,this.convertFunc=n,this.isIndex=e??false,this.isUnique=a??false,this.defaultValue=r,this.foreignReference=u,this.isPrimary=y??false;}encodeMutation(t,n,e){return {value:n,_meta:{timestamp:e}}}mergeMutation(t,n,e){return e&&e._meta.timestamp&&n._meta.timestamp&&e._meta.timestamp.localeCompare(n._meta.timestamp)>=0?[e,null]:[{value:this.convertFunc?this.convertFunc(n.value):n.value,_meta:n._meta},n]}getStorageFieldType(){return {type:this.storageType,nullable:false,index:this.isIndex,unique:this.isUnique,default:this.defaultValue,references:this.foreignReference,primary:this.isPrimary}}unique(){return new i(this.storageType,this.convertFunc,this.isIndex,true,this.defaultValue,this.foreignReference,this.isPrimary)}index(){return new i(this.storageType,this.convertFunc,true,this.isUnique,this.defaultValue,this.foreignReference,this.isPrimary)}default(t){return new i(this.storageType,this.convertFunc,this.isIndex,this.isUnique,t,this.foreignReference,this.isPrimary)}primary(){return new i(this.storageType,this.convertFunc,this.isIndex,this.isUnique,this.defaultValue,this.foreignReference,true)}nullable(){return new T(this)}},d=class i extends l{constructor(){super("integer",t=>Number(t));}static create(){return new i}},b=d.create,o=class i extends l{constructor(t){super("varchar",void 0,void 0,void 0,void 0,t);}static create(){return new i}static createId(){return new i().index().unique().primary()}static createReference(t){return new i(t)}},I=o.create,O=o.createId,K=o.createReference,p=class i extends l{constructor(){super("boolean",t=>typeof t=="string"?t.toLowerCase()==="true":!!t);}static create(){return new i}},A=p.create,f=class i extends l{constructor(){super("timestamp",t=>typeof t=="string"?new Date(t):t);}static create(){return new i}},j=f.create;var v=class i extends s{name;fields;relations;constructor(t,n,e){super(),this.name=t,this.fields=n,this.relations=e??{};}encodeMutation(t,n,e){return Object.fromEntries(Object.entries(n).map(([a,r])=>[a,(this.fields[a]??this.relations[a]).encodeMutation("set",r,e)]))}mergeMutation(t,n,e){let a={};return [{value:{...(e==null?void 0:e.value)??{},...Object.fromEntries(Object.entries(n).map(([r,u])=>{let y=this.fields[r]??this.relations[r];if(!y)return [r,u];let[x,L]=y.mergeMutation(t,u,e==null?void 0:e.value[r]);return L&&(a[r]=L),[r,x]}))}},a]}setRelations(t){return new i(this.name,this.fields,t)}getStorageFieldType(){throw new Error("Method not implemented.")}static create(t,n){return new i(t,n)}},w=v.create,c=class i extends s{entity;type;required;relationalColumn;foreignColumn;sourceEntity;constructor(t,n,e,a,r){super(),this.entity=t,this.type=n,this.required=r??false,this.relationalColumn=e,this.foreignColumn=a;}encodeMutation(t,n,e){if(t!=="set")throw new Error("Mutation type not implemented.");if(this.type==="many")throw new Error("Many not implemented.");return {value:n,_meta:{timestamp:e}}}mergeMutation(t,n,e){var a;return this.type==="many"?e?[e,null]:[n,n]:(a=e==null?void 0:e._meta)!=null&&a.timestamp&&n._meta.timestamp&&e._meta.timestamp.localeCompare(n._meta.timestamp)>=0?[e,null]:[n,n]}getStorageFieldType(){return {type:"varchar",nullable:!this.required,references:`${this.entity.name}.${String(this.foreignColumn??this.relationalColumn??"id")}`}}toJSON(){return {entityName:this.entity.name,type:this.type,required:this.required,relationalColumn:this.relationalColumn,foreignColumn:this.foreignColumn}}static createOneFactory(){return (t,n,e)=>new i(t,"one",n,void 0,e??false)}static createManyFactory(){return (t,n,e)=>new i(t,"many",void 0,n,e??false)}},C=(i,t)=>({$type:"relations",objectName:i.name,relations:t({one:c.createOneFactory(),many:c.createManyFactory()})}),m=i=>i?Array.isArray(i.value)?i.value.map(n=>m(n)):typeof i.value!="object"||i.value===null||i.value instanceof Date?i.value:Object.fromEntries(Object.entries(i.value).map(([n,e])=>Array.isArray(e)?[n,e.map(a=>m(a))]:[n,m(e)])):void 0,V=i=>Object.fromEntries(Object.entries(i).flatMap(([t,n])=>{if(n.$type==="relations")return [];let e=n,a=Object.values(i).find(r=>r.$type==="relations"&&r.objectName===n.name);return a&&(e=e.setRelations(a.relations)),[[e.name,e]]}));var h={CRITICAL:0,ERROR:1,WARN:2,INFO:3,DEBUG:4};exports.LiveAtomicType=l;exports.LiveBoolean=p;exports.LiveNumber=d;exports.LiveObject=v;exports.LiveString=o;exports.LiveTimestamp=f;exports.LiveType=s;exports.LogLevel=h;exports.NullableLiveType=T;exports.Relation=c;exports.boolean=A;exports.createRelations=C;exports.createSchema=V;exports.id=O;exports.inferValue=m;exports.number=b;exports.object=w;exports.reference=K;exports.string=I;exports.timestamp=j;
+'use strict';require('js-xxhash');var r=class{_value;_meta;_encodeInput;_decodeInput};var s=class e extends r{inner;constructor(t){super(),this.inner=t;}encodeMutation(t,i,n){return this.inner.encodeMutation(t,i,n)}mergeMutation(t,i,n){return this.inner.mergeMutation(t,i,n)}getStorageFieldType(){return {...this.inner.getStorageFieldType(),nullable:true}}unique(){return new e(this.inner.unique())}index(){return new e(this.inner.index())}default(t){let i=new o(this.inner.storageType,this.inner.convertFunc,this.inner.isIndex,this.inner.isUnique,t,this.inner.foreignReference,this.inner.isPrimary);return new e(i)}primary(){return new e(this.inner.primary())}},o=class e extends r{storageType;convertFunc;isIndex;isUnique;defaultValue;foreignReference;isPrimary;constructor(t,i,n,a,l,d,T){super(),this.storageType=t,this.convertFunc=i,this.isIndex=n??false,this.isUnique=a??false,this.defaultValue=l,this.foreignReference=d,this.isPrimary=T??false;}encodeMutation(t,i,n){return {value:i,_meta:{timestamp:n}}}mergeMutation(t,i,n){return n&&n._meta.timestamp&&i._meta.timestamp&&n._meta.timestamp.localeCompare(i._meta.timestamp)>0?[n,null]:[{value:this.convertFunc?this.convertFunc(i.value):i.value,_meta:i._meta},i]}getStorageFieldType(){return {type:this.storageType,nullable:false,index:this.isIndex,unique:this.isUnique,default:this.defaultValue,references:this.foreignReference,primary:this.isPrimary}}unique(){return new e(this.storageType,this.convertFunc,this.isIndex,true,void 0,this.foreignReference,this.isPrimary)}index(){return new e(this.storageType,this.convertFunc,true,this.isUnique,void 0,this.foreignReference,this.isPrimary)}default(t){return new e(this.storageType,this.convertFunc,this.isIndex,this.isUnique,t,this.foreignReference,this.isPrimary)}primary(){return new e(this.storageType,this.convertFunc,this.isIndex,this.isUnique,void 0,this.foreignReference,true)}nullable(){if(this.defaultValue===void 0){let t=new e(this.storageType,this.convertFunc,this.isIndex,this.isUnique,null,this.foreignReference,this.isPrimary);return new s(t)}return new s(this)}withMeta(){return new e(this.storageType,this.convertFunc,this.isIndex,this.isUnique,this.defaultValue,this.foreignReference,this.isPrimary)}},p=class e extends o{constructor(){super("integer",t=>Number(t));}static create(){return new e}},V=p.create,y=class e extends o{constructor(t){super("varchar",void 0,void 0,void 0,void 0,t);}static create(){return new e}static createId(){return new e().index().unique().primary()}static createReference(t){return new e(t)}},M=y.create,I=y.createId,A=y.createReference,f=class e extends o{constructor(){super("boolean",t=>typeof t=="string"?t.toLowerCase()==="true":!!t);}static create(){return new e}},b=f.create,m=class e extends o{constructor(){super("timestamp",t=>typeof t=="string"?new Date(t):t);}static create(){return new e}},w=m.create,v=class e extends o{enumValues;enumName;constructor(t,i,n,a,l){super("varchar",void 0,i,n,a,void 0,l),this.enumValues=t,this.enumName=`enum_${t.slice(0,5).join("_").slice(0,50)}`;}getStorageFieldType(){return {type:"varchar",nullable:false,index:this.isIndex,unique:this.isUnique,default:this.defaultValue,primary:this.isPrimary,enumValues:this.enumValues,enumName:this.enumName}}unique(){return new e(this.enumValues,this.isIndex,true,void 0,this.isPrimary)}index(){return new e(this.enumValues,true,this.isUnique,void 0,this.isPrimary)}default(t){return new e(this.enumValues,this.isIndex,this.isUnique,t,this.isPrimary)}primary(){return new e(this.enumValues,this.isIndex,this.isUnique,void 0,true)}nullable(){if(this.defaultValue===void 0){let t=new e(this.enumValues,this.isIndex,this.isUnique,null,this.isPrimary);return new s(t)}return new s(this)}static create(t){return new e(t)}},N=v.create,x=class e extends o{constructor(t,i,n,a){super("jsonb",l=>typeof l=="string"?JSON.parse(l):l,t,i,n,void 0,a);}getStorageFieldType(){return {type:"jsonb",nullable:false,index:this.isIndex,unique:this.isUnique,default:this.defaultValue!==void 0?JSON.stringify(this.defaultValue):void 0,primary:this.isPrimary}}unique(){return new e(this.isIndex,true,void 0,this.isPrimary)}index(){return new e(true,this.isUnique,void 0,this.isPrimary)}default(t){return new e(this.isIndex,this.isUnique,t,this.isPrimary)}primary(){return new e(this.isIndex,this.isUnique,void 0,true)}nullable(){if(this.defaultValue===void 0){let t=new e(this.isIndex,this.isUnique,null,this.isPrimary);return new s(t)}return new s(this)}static create(){return new e}},S=x.create;var u=class e extends r{entity;type;required;relationalColumn;foreignColumn;sourceEntity;constructor(t,i,n,a,l){super(),this.entity=t,this.type=i,this.required=l??false,this.relationalColumn=n,this.foreignColumn=a;}encodeMutation(t,i,n){if(t!=="set")throw new Error("Mutation type not implemented.");if(this.type==="many")throw new Error("Many not implemented.");return {value:i,_meta:{timestamp:n}}}mergeMutation(t,i,n){var a;return this.type==="many"?n?[n,null]:[i,i]:(a=n==null?void 0:n._meta)!=null&&a.timestamp&&i._meta.timestamp&&n._meta.timestamp.localeCompare(i._meta.timestamp)>=0?[n,null]:[i,i]}getStorageFieldType(){return {type:"varchar",nullable:!this.required,references:`${this.entity.name}.${String(this.foreignColumn??this.relationalColumn??"id")}`}}toJSON(){return {entityName:this.entity.name,type:this.type,required:this.required,relationalColumn:this.relationalColumn,foreignColumn:this.foreignColumn}}static createOneFactory(){return (t,i,n)=>new e(t,"one",i,void 0,n??false)}static createManyFactory(){return (t,i,n)=>new e(t,"many",void 0,i,n??false)}},F=(e,t)=>({$type:"relations",collectionName:e.name,objectName:e.name,relations:t({one:u.createOneFactory(),many:u.createManyFactory()})});var c=class e extends r{name;fields;relations;constructor(t,i,n){super(),this.name=t,this.fields=i,this.relations=n??{};}encodeMutation(t,i,n){return Object.fromEntries(Object.entries(i).map(([a,l])=>[a,(this.fields[a]??this.relations[a]).encodeMutation("set",l,n)]))}mergeMutation(t,i,n){let a={};return [{value:{...(n==null?void 0:n.value)??{},...Object.fromEntries(Object.entries(i).map(([l,d])=>{let T=this.fields[l]??this.relations[l];if(!T)return [l,d];let[C,R]=T.mergeMutation(t,d,n==null?void 0:n.value[l]);return R&&(a[l]=R),[l,C]}))}},a]}setRelations(t){return new e(this.name,this.fields,t)}getStorageFieldType(){throw new Error("Method not implemented.")}static create(t,i){if(E(i)){let n=i,a=new e(t,n.fields);if(n.relations){let l=n.relations({one:u.createOneFactory(),many:u.createManyFactory()});return new e(t,n.fields,l)}return a}return new e(t,i,void 0)}};function E(e){return typeof e=="object"&&e!==null&&"fields"in e&&typeof e.fields=="object"}var g=c.create,K=g,D=c;var h=e=>typeof e=="object"&&e!==null&&"value"in e&&!Array.isArray(e),L=e=>e?Array.isArray(e.value)?e.value.map(i=>h(i)?L(i):i):typeof e.value!="object"||e.value===null||e.value instanceof Date?e.value:Object.fromEntries(Object.entries(e.value).map(([i,n])=>Array.isArray(n)?[i,n.map(a=>h(a)?L(a):a)]:h(n)?[i,L(n)]:[i,n])):void 0;var O=e=>Object.fromEntries(Object.entries(e).flatMap(([t,i])=>{if(i.$type==="relations")return [];let n=i,a=Object.values(e).find(l=>l.$type==="relations"&&l.collectionName===i.name);return a&&(n=n.setRelations(a.relations)),[[n.name,n]]}));var q={CRITICAL:0,ERROR:1,WARN:2,INFO:3,DEBUG:4};exports.LiveAtomicType=o;exports.LiveBoolean=f;exports.LiveCollection=c;exports.LiveEnum=v;exports.LiveJson=x;exports.LiveNumber=p;exports.LiveObject=D;exports.LiveString=y;exports.LiveTimestamp=m;exports.LiveType=r;exports.LogLevel=q;exports.NullableLiveType=s;exports.Relation=u;exports.boolean=b;exports.collection=g;exports.createRelations=F;exports.createSchema=O;exports.enumType=N;exports.id=I;exports.inferValue=L;exports.json=S;exports.number=V;exports.object=K;exports.reference=A;exports.string=M;exports.timestamp=w;

package/dist/index.d.cts

@@ -1 +1 @@
-export { b as IncludeClause, F as InferIndex, d as InferInsert, c as InferLiveObject, I as InferLiveObjectWithRelationalIds, h as InferLiveObjectWithoutRelations, E as InferLiveType, e as InferUpdate, n as LiveAtomicType, v as LiveBoolean, p as LiveNumber, j as LiveObject, L as LiveObjectAny, i as LiveObjectMutationInput, r as LiveString, x as LiveTimestamp, C as LiveType, D as LiveTypeAny, z as LiveTypeMeta, g as LogLevel, M as MaterializedLiveType, A as MutationType, N as NullableLiveType, R as Relation, a as Schema, B as StorageFieldType, W as WhereClause, w as boolean, k as createRelations, m as createSchema, t as id, l as inferValue, q as number, o as object, u as reference, s as string, y as timestamp } from './index-BtsKDfTE.cjs';
+export { A as AtomicMeta, B as BaseMeta, V as CollectionConfig, I as IncludeClause, o as InferIndex, b as InferInsert, f as InferLiveCollection, a1 as InferLiveCollectionWithRelationalIds, a0 as InferLiveCollectionWithoutRelations, a as InferLiveObject, g as InferLiveObjectWithRelationalIds, a2 as InferLiveObjectWithoutRelations, n as InferLiveType, c as InferUpdate, q as LiveAtomicType, t as LiveBoolean, Q as LiveCollection, e as LiveCollectionAny, U as LiveCollectionMutationInput, v as LiveEnum, w as LiveJson, r as LiveNumber, Y as LiveObject, L as LiveObjectAny, Z as LiveObjectMutationInput, s as LiveString, u as LiveTimestamp, j as LiveType, k as LiveTypeAny, p as LiveTypeMeta, i as LogLevel, M as MaterializedLiveType, l as MutationType, N as NullableLiveType, R as Relation, J as RelationAny, K as RelationConnectors, O as RelationsDecl, d as Schema, m as StorageFieldType, _ as SubQueryInclude, W as WhereClause, P as _ILiveCollectionAny, z as boolean, T as collection, H as createRelations, a3 as createSchema, F as enumType, D as id, $ as inferValue, G as json, x as number, X as object, E as reference, y as string, C as timestamp } from './index-hO1iQ-VU.cjs';

package/dist/index.d.ts

@@ -1 +1 @@
-export { b as IncludeClause, F as InferIndex, d as InferInsert, c as InferLiveObject, I as InferLiveObjectWithRelationalIds, h as InferLiveObjectWithoutRelations, E as InferLiveType, e as InferUpdate, n as LiveAtomicType, v as LiveBoolean, p as LiveNumber, j as LiveObject, L as LiveObjectAny, i as LiveObjectMutationInput, r as LiveString, x as LiveTimestamp, C as LiveType, D as LiveTypeAny, z as LiveTypeMeta, g as LogLevel, M as MaterializedLiveType, A as MutationType, N as NullableLiveType, R as Relation, a as Schema, B as StorageFieldType, W as WhereClause, w as boolean, k as createRelations, m as createSchema, t as id, l as inferValue, q as number, o as object, u as reference, s as string, y as timestamp } from './index-BtsKDfTE.js';
+export { A as AtomicMeta, B as BaseMeta, V as CollectionConfig, I as IncludeClause, o as InferIndex, b as InferInsert, f as InferLiveCollection, a1 as InferLiveCollectionWithRelationalIds, a0 as InferLiveCollectionWithoutRelations, a as InferLiveObject, g as InferLiveObjectWithRelationalIds, a2 as InferLiveObjectWithoutRelations, n as InferLiveType, c as InferUpdate, q as LiveAtomicType, t as LiveBoolean, Q as LiveCollection, e as LiveCollectionAny, U as LiveCollectionMutationInput, v as LiveEnum, w as LiveJson, r as LiveNumber, Y as LiveObject, L as LiveObjectAny, Z as LiveObjectMutationInput, s as LiveString, u as LiveTimestamp, j as LiveType, k as LiveTypeAny, p as LiveTypeMeta, i as LogLevel, M as MaterializedLiveType, l as MutationType, N as NullableLiveType, R as Relation, J as RelationAny, K as RelationConnectors, O as RelationsDecl, d as Schema, m as StorageFieldType, _ as SubQueryInclude, W as WhereClause, P as _ILiveCollectionAny, z as boolean, T as collection, H as createRelations, a3 as createSchema, F as enumType, D as id, $ as inferValue, G as json, x as number, X as object, E as reference, y as string, C as timestamp } from './index-hO1iQ-VU.js';