@dxos/echo 0.8.4-main.e098934 → 0.8.4-main.e8ec1fe

package/dist/types/src/internal/testing/types.d.ts

@@ -0,0 +1,381 @@
+import * as Schema from 'effect/Schema';
+import { Ref, type Ref$ } from '../ref';
+/**
+ * @deprecated
+ */
+export declare namespace Testing {
+    const TestNestedSchema: Schema.mutable<Schema.Struct<{
+        field: typeof Schema.String;
+    }>>;
+    export type TestNestedSchema = Schema.Schema.Type<typeof TestNestedSchema>;
+    export const TestNestedType: import("..").EchoTypeSchema<Schema.mutable<Schema.Struct<{
+        field: typeof Schema.String;
+    }>>, {}>;
+    const EmptySchemaType_base: import("..").TypedObjectPrototype<import("..").TypedObjectFields<{}, import("..").TypedObjectOptions>, Schema.Struct.Encoded<{}>>;
+    export class EmptySchemaType extends EmptySchemaType_base {
+    }
+    export const TestSchema: Schema.mutable<Schema.SchemaClass<{
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nested?: Ref<{
+            readonly id: import("@dxos/keys").ObjectId;
+            field: string;
+        }> | undefined;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+    }, {
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+        readonly nested?: import("@dxos/echo-protocol").EncodedReference | undefined;
+    }, never>>;
+    export type TestSchema = Schema.Schema.Type<typeof TestSchema>;
+    const TestSchemaType_base: import("..").TypedObjectPrototype<import("..").TypedObjectFields<{
+        string: typeof Schema.String;
+        number: typeof Schema.Number;
+        nullableShapeArray: Schema.mutable<Schema.Array$<Schema.Union<[Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["circle"]>;
+            radius: typeof Schema.Number;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["square"]>;
+            side: typeof Schema.Number;
+        }>]>, typeof Schema.Null]>>>;
+        boolean: typeof Schema.Boolean;
+        null: typeof Schema.Null;
+        undefined: typeof Schema.Undefined;
+        stringArray: Schema.mutable<Schema.Array$<typeof Schema.String>>;
+        twoDimNumberArray: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Array$<typeof Schema.Number>>>>;
+        object: Schema.mutable<Schema.Struct<{
+            field: typeof Schema.String;
+        }>>;
+        objectArray: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            field: typeof Schema.String;
+        }>>>>;
+        nested: Schema.optional<Ref$<{
+            readonly id: import("@dxos/keys").ObjectId;
+            field: string;
+        }>>;
+        other: typeof Schema.Any;
+    }, {
+        partial: true;
+    }>, Schema.Struct.Encoded<{
+        string: typeof Schema.String;
+        number: typeof Schema.Number;
+        nullableShapeArray: Schema.mutable<Schema.Array$<Schema.Union<[Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["circle"]>;
+            radius: typeof Schema.Number;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["square"]>;
+            side: typeof Schema.Number;
+        }>]>, typeof Schema.Null]>>>;
+        boolean: typeof Schema.Boolean;
+        null: typeof Schema.Null;
+        undefined: typeof Schema.Undefined;
+        stringArray: Schema.mutable<Schema.Array$<typeof Schema.String>>;
+        twoDimNumberArray: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Array$<typeof Schema.Number>>>>;
+        object: Schema.mutable<Schema.Struct<{
+            field: typeof Schema.String;
+        }>>;
+        objectArray: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            field: typeof Schema.String;
+        }>>>>;
+        nested: Schema.optional<Ref$<{
+            readonly id: import("@dxos/keys").ObjectId;
+            field: string;
+        }>>;
+        other: typeof Schema.Any;
+    }>>;
+    export class TestSchemaType extends TestSchemaType_base {
+    }
+    export const TestType: import("..").EchoTypeSchema<Schema.mutable<Schema.SchemaClass<{
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nested?: Ref<{
+            readonly id: import("@dxos/keys").ObjectId;
+            field: string;
+        }> | undefined;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+    }, {
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+        readonly nested?: import("@dxos/echo-protocol").EncodedReference | undefined;
+    }, never>>, {}>;
+    export class TestClass {
+        field: string;
+        toJSON(): {
+            field: string;
+        };
+    }
+    export const TestSchemaWithClass: Schema.mutable<Schema.extend<Schema.mutable<Schema.SchemaClass<{
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nested?: Ref<{
+            readonly id: import("@dxos/keys").ObjectId;
+            field: string;
+        }> | undefined;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+    }, {
+        readonly string?: string | undefined;
+        readonly number?: number | undefined;
+        readonly boolean?: boolean | undefined;
+        readonly undefined?: undefined;
+        readonly object?: {
+            field: string;
+        } | undefined;
+        readonly null?: null | undefined;
+        readonly other?: any;
+        readonly nullableShapeArray?: ({
+            readonly type: "circle";
+            readonly radius: number;
+        } | {
+            readonly type: "square";
+            readonly side: number;
+        } | null)[] | undefined;
+        readonly stringArray?: string[] | undefined;
+        readonly twoDimNumberArray?: number[][] | undefined;
+        readonly objectArray?: {
+            field: string;
+        }[] | undefined;
+        readonly nested?: import("@dxos/echo-protocol").EncodedReference | undefined;
+    }, never>>, Schema.mutable<Schema.Struct<{
+        classInstance: Schema.optional<Schema.instanceOf<TestClass>>;
+    }>>>>;
+    export type TestSchemaWithClass = Schema.Schema.Type<typeof TestSchemaWithClass>;
+    const Person_base: import("..").TypedObjectPrototype<import("..").TypedObjectFields<{
+        name: typeof Schema.String;
+        username: typeof Schema.String;
+        email: typeof Schema.String;
+        phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+            label: typeof Schema.String;
+            number: typeof Schema.String;
+        }>>>;
+        tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+        address: Schema.Struct<{
+            city: Schema.optional<typeof Schema.String>;
+            state: Schema.optional<typeof Schema.String>;
+            zip: Schema.optional<typeof Schema.String>;
+            coordinates: Schema.Struct<{
+                lat: Schema.optional<typeof Schema.Number>;
+                lng: Schema.optional<typeof Schema.Number>;
+            }>;
+        }>;
+    }, {
+        partial: true;
+    }>, Schema.Struct.Encoded<{
+        name: typeof Schema.String;
+        username: typeof Schema.String;
+        email: typeof Schema.String;
+        phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+            label: typeof Schema.String;
+            number: typeof Schema.String;
+        }>>>;
+        tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+        address: Schema.Struct<{
+            city: Schema.optional<typeof Schema.String>;
+            state: Schema.optional<typeof Schema.String>;
+            zip: Schema.optional<typeof Schema.String>;
+            coordinates: Schema.Struct<{
+                lat: Schema.optional<typeof Schema.Number>;
+                lng: Schema.optional<typeof Schema.Number>;
+            }>;
+        }>;
+    }>>;
+    export class Person extends Person_base {
+    }
+    const Task_base: import("..").TypedObjectPrototype<import("..").TypedObjectFields<{
+        title: Schema.optional<typeof Schema.String>;
+        completed: Schema.optional<typeof Schema.Boolean>;
+        assignee: Schema.optional<Ref$<import("..").TypedObjectFields<{
+            name: typeof Schema.String;
+            username: typeof Schema.String;
+            email: typeof Schema.String;
+            phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+                label: typeof Schema.String;
+                number: typeof Schema.String;
+            }>>>;
+            tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+            address: Schema.Struct<{
+                city: Schema.optional<typeof Schema.String>;
+                state: Schema.optional<typeof Schema.String>;
+                zip: Schema.optional<typeof Schema.String>;
+                coordinates: Schema.Struct<{
+                    lat: Schema.optional<typeof Schema.Number>;
+                    lng: Schema.optional<typeof Schema.Number>;
+                }>;
+            }>;
+        }, {
+            partial: true;
+        }>>>;
+        previous: Schema.optional<Schema.suspend<Ref<Task>, import("@dxos/echo-protocol").EncodedReference, never>>;
+        subTasks: Schema.optional<Schema.mutable<Schema.Array$<Schema.suspend<Ref<Task>, import("@dxos/echo-protocol").EncodedReference, never>>>>;
+        description: Schema.optional<typeof Schema.String>;
+    }, {
+        partial: true;
+    }>, Schema.Struct.Encoded<{
+        title: Schema.optional<typeof Schema.String>;
+        completed: Schema.optional<typeof Schema.Boolean>;
+        assignee: Schema.optional<Ref$<import("..").TypedObjectFields<{
+            name: typeof Schema.String;
+            username: typeof Schema.String;
+            email: typeof Schema.String;
+            phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+                label: typeof Schema.String;
+                number: typeof Schema.String;
+            }>>>;
+            tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+            address: Schema.Struct<{
+                city: Schema.optional<typeof Schema.String>;
+                state: Schema.optional<typeof Schema.String>;
+                zip: Schema.optional<typeof Schema.String>;
+                coordinates: Schema.Struct<{
+                    lat: Schema.optional<typeof Schema.Number>;
+                    lng: Schema.optional<typeof Schema.Number>;
+                }>;
+            }>;
+        }, {
+            partial: true;
+        }>>>;
+        previous: Schema.optional<Schema.suspend<Ref<Task>, import("@dxos/echo-protocol").EncodedReference, never>>;
+        subTasks: Schema.optional<Schema.mutable<Schema.Array$<Schema.suspend<Ref<Task>, import("@dxos/echo-protocol").EncodedReference, never>>>>;
+        description: Schema.optional<typeof Schema.String>;
+    }>>;
+    export class Task extends Task_base {
+    }
+    export const HasManager: import("..").EchoTypeSchema<Schema.Struct<{
+        since: Schema.optional<typeof Schema.String>;
+    }>, import("..").RelationSourceTargetRefs<import("..").TypedObjectFields<{
+        name: typeof Schema.String;
+        username: typeof Schema.String;
+        email: typeof Schema.String;
+        phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+            label: typeof Schema.String;
+            number: typeof Schema.String;
+        }>>>;
+        tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+        address: Schema.Struct<{
+            city: Schema.optional<typeof Schema.String>;
+            state: Schema.optional<typeof Schema.String>;
+            zip: Schema.optional<typeof Schema.String>;
+            coordinates: Schema.Struct<{
+                lat: Schema.optional<typeof Schema.Number>;
+                lng: Schema.optional<typeof Schema.Number>;
+            }>;
+        }>;
+    }, {
+        partial: true;
+    }>, import("..").TypedObjectFields<{
+        name: typeof Schema.String;
+        username: typeof Schema.String;
+        email: typeof Schema.String;
+        phoneNumbers: Schema.optional<Schema.Array$<Schema.Struct<{
+            label: typeof Schema.String;
+            number: typeof Schema.String;
+        }>>>;
+        tasks: Schema.suspend<Ref<Task>[], import("@dxos/echo-protocol").EncodedReference[], never>;
+        address: Schema.Struct<{
+            city: Schema.optional<typeof Schema.String>;
+            state: Schema.optional<typeof Schema.String>;
+            zip: Schema.optional<typeof Schema.String>;
+            coordinates: Schema.Struct<{
+                lat: Schema.optional<typeof Schema.Number>;
+                lng: Schema.optional<typeof Schema.Number>;
+            }>;
+        }>;
+    }, {
+        partial: true;
+    }>>>;
+    export interface HasManager extends Schema.Schema.Type<typeof HasManager> {
+    }
+    export {};
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/src/internal/testing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/internal/testing/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AAExC;;GAEG;AAEH,yBAAiB,OAAO,CAAC;IAavB,MAAM,gBAAgB;;OAA0D,CAAC;IACjF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC;IAC3E,MAAM,CAAC,MAAM,cAAc;;YAE1B,CAAC;;IAOF,MAAM,OAAO,eAAgB,SAAQ,oBAG/B;KAAG;IAiBT,MAAM,CAAC,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAwD,CAAC;IAChF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE/D,MAAM,OAAO,cAAe,SAAQ,mBAGP;KAAG;IAGhC,MAAM,CAAC,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKpB,CAAC;IAEF,MAAM,OAAO,SAAS;QACpB,KAAK,SAAW;QAChB,MAAM;;;KAGP;IAGD,MAAM,CAAC,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAS/B,CAAC;IAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEjF,MAAM,OAAO,MAAO,SAAQ,WAqB3B;KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEJ,MAAM,OAAO,IAAK,SAAQ,SAazB;KAAG;IAEJ,MAAM,CAAC,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAStB,CAAC;IACF,MAAM,WAAW,UAAW,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC;KAAG;;CAC7E"}

package/dist/types/src/internal/testing/utils.d.ts

@@ -0,0 +1,10 @@
+import type * as SchemaAST from 'effect/SchemaAST';
+export declare const updateCounter: (touch: () => void) => {
+    [Symbol.dispose]: () => void;
+    readonly count: number;
+};
+/**
+ * Converts AST to a format that can be compared with test matchers.
+ */
+export declare const prepareAstForCompare: (obj: SchemaAST.AST) => any;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/src/internal/testing/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/internal/testing/utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,SAAS,MAAM,kBAAkB,CAAC;AAQnD,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,IAAI;;;CAc9C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,SAAS,CAAC,GAAG,KAAG,GAqBtD,CAAC"}

package/dist/types/src/internal/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export type * from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/internal/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/internal/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC;AACxB,mBAAmB,QAAQ,CAAC"}

package/dist/types/src/internal/types/types.d.ts

@@ -0,0 +1,79 @@
+import * as Schema from 'effect/Schema';
+import { Reference } from '@dxos/echo-protocol';
+import { type JsonPath } from '@dxos/effect';
+import { type ObjectId } from '@dxos/keys';
+import { type EntityKindId, type ObjectMeta } from '../object';
+import { ATTR_META } from '../object/model';
+/**
+ * Base type for all data objects (reactive, ECHO, and other raw objects).
+ * NOTE: This describes the base type for all database objects.
+ * It is stricter than `T extends {}` or `T extends object`.
+ */
+/**
+ * @deprecated use Obj.Any
+ */
+export type BaseObject = Record<string, any>;
+/**
+ * Marker interface for object with an `id`.
+ */
+export interface HasId {
+    readonly id: ObjectId;
+}
+export type WithId<T extends BaseObject = BaseObject> = T & HasId;
+export type ExcludeId<T extends BaseObject> = Omit<T, 'id'>;
+/**
+ * Properties that are required for object creation.
+ */
+export type CreationProps<T extends BaseObject> = Omit<T, 'id' | typeof EntityKindId>;
+export type PropertyKey<T extends BaseObject> = Extract<keyof ExcludeId<T>, string>;
+export type WithMeta = {
+    [ATTR_META]?: ObjectMeta;
+};
+/**
+ * The raw object should not include the ECHO id, but may include metadata.
+ */
+export declare const RawObject: <S extends Schema.Schema.AnyNoContext>(schema: S) => Schema.Schema<ExcludeId<Schema.Schema.Type<S>> & WithMeta, Schema.Schema.Encoded<S>>;
+/**
+ * Utility to split meta property from raw object.
+ * @deprecated Bad API.
+ */
+export declare const splitMeta: <T>(object: T & WithMeta) => {
+    object: T;
+    meta?: ObjectMeta;
+};
+export declare const getValue: <T extends object>(obj: T, path: JsonPath) => any;
+export declare const setValue: <T extends object>(obj: T, path: JsonPath, value: any) => T;
+/**
+ * Returns a reference that will be used to point to a schema.
+ * @deprecated Use {@link getSchemaDXN} instead.
+ */
+export declare const getTypeReference: (schema: Schema.Schema.All | undefined) => Reference | undefined;
+/**
+ * Returns a reference that will be used to point to a schema.
+ * @throws If it is not possible to reference this schema.
+ *
+ * @deprecated Use {@link getSchemaDXN} instead.
+ */
+export declare const requireTypeReference: (schema: Schema.Schema.AnyNoContext) => Reference;
+/**
+ * Checks if the object is an instance of the schema.
+ * Only typename is compared, the schema version is ignored.
+ *
+ * The following cases are considered to mean that the object is an instance of the schema:
+ *  - Object was created with this exact schema.
+ *  - Object was created with a different version of this schema.
+ *  - Object was created with a different schema (maybe dynamic) that has the same typename.
+ */
+export declare const isInstanceOf: <Schema extends Schema.Schema.AnyNoContext>(schema: Schema, object: any) => object is Schema.Schema.Type<Schema>;
+/**
+ * Object that has an associated typename.
+ * The typename is retrievable using {@link getTypename}.
+ * The object can be used with {@link isInstanceOf} to check if it is an instance of a schema.
+ */
+export type HasTypename = {};
+/**
+ * Canonical type for all ECHO objects.
+ */
+export interface AnyEchoObject extends HasId, HasTypename {
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/src/internal/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/internal/types/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,KAAK,QAAQ,EAAiB,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAIhD,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAwB,MAAM,WAAW,CAAC;AACrF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;GAIG;AAGH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACvB;AAGD,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI,CAAC,GAAG,KAAK,CAAC;AAElE,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAE5D;;GAEG;AAEH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,YAAY,CAAC,CAAC;AAEtF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAGpF,MAAM,MAAM,QAAQ,GAAG;IAAE,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,YAAY,EAC5D,QAAQ,CAAC,KACR,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAErF,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,QAAQ,CAAC,GAAG,QAAQ,KAAG;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,UAAU,CAAA;CAIjF,CAAC;AAGF,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,QAAQ,KAAG,GAKnE,CAAC;AAGF,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,QAAQ,EAAE,OAAO,GAAG,KAAG,CAM/E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,CAAC,MAAM,CAAC,GAAG,GAAG,SAAS,KAAG,SAAS,GAAG,SAUpF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,CAAC,MAAM,CAAC,YAAY,KAAG,SAQzE,CAAC;AAGF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,YAAY,EACpE,QAAQ,MAAM,EACd,QAAQ,GAAG,KACV,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CA0BrC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,EAAE,CAAC;AAE7B;;GAEG;AAEH,MAAM,WAAW,aAAc,SAAQ,KAAK,EAAE,WAAW;CAAG"}

package/dist/types/src/internal/types/types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.test.d.ts.map

package/dist/types/src/internal/types/types.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.test.d.ts","sourceRoot":"","sources":["../../../../../src/internal/types/types.test.ts"],"names":[],"mappings":""}

package/dist/types/src/internal/types/util.d.ts

@@ -0,0 +1,5 @@
+import { type BaseObject } from './types';
+export type ToMutable<T> = T extends BaseObject ? {
+    -readonly [K in keyof T]: T[K] extends readonly (infer U)[] ? U[] : T[K];
+} : T;
+//# sourceMappingURL=util.d.ts.map

package/dist/types/src/internal/types/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../../src/internal/types/util.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAC3C;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAC5E,CAAC,CAAC"}

package/dist/types/src/query/index.d.ts

@@ -1,2 +1,2 @@
-export * from './dsl';
+export * from './query';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/src/query/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/query/index.ts"],"names":[],"mappings":"AAIA,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/query/index.ts"],"names":[],"mappings":"AAKA,cAAc,SAAS,CAAC"}