doxum 0.1.27 → 0.1.28

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { $ as table, A as ParseError, B as DocumentListConfig, C as Read, D as ChangeSet, E as Change, F as CollectionPath, G as ReadonlyValue, H as DocumentTreeValue, I as PathValueOf, J as field, K as Schema, L as SchemaPath, M as parse, N as CollectionEntry, O as MemberChange, P as CollectionId, Q as optional, R as DocumentAddress, S as Draft, T as snapshot, U as Infer, V as DocumentTreeNode, W as ObjectSchema, X as map, Y as list, Z as object, _ as Unsubscribe, a as DocumentProblem, b as CollectionImpact, c as HistoryState, d as OperationResult, et as tree, f as ReadonlyDocument, g as Readable, h as TransactionResult, i as DocumentDisposedError, j as ParseIssue, k as ValueTransition, l as LocalHistory, m as TransactionRejected, n as DocumentCommit, o as DocumentReentrancyError, p as Synchronous, q as Validator, r as DocumentDiagnostic, s as DocumentRuntime, t as CommitSource, tt as variant, u as ObserverError, v as MutationIssue, w as replace, x as DocumentImpact, y as MutationIssueCode, z as DocumentAnchor } from "./contract-CNR6BS75.cjs";
-import { a as Projection, d as ExternalCollectionRead, f as ExternalCollectionSource, g as ProjectionError, h as ProjectionDisposedError, i as KeyedProjection, m as ExternalValueSource, n as CollectionInputDraft, p as ExternalValueEvent, r as Input, t as CollectionInput, u as ExternalCollectionEvent } from "./definition-CDOuvb5C.cjs";
+import { _ as ProjectionDisposedError, a as Input, f as ExternalCollectionEvent, g as ExternalValueSource, h as ExternalValueEvent, i as CollectionInputDraft, m as ExternalCollectionSource, n as KeyedDependencyValues, o as KeyedProjection, p as ExternalCollectionRead, r as CollectionInput, s as Projection, t as KeyedDependencies, v as ProjectionError } from "./dependency-B3E65M1E.cjs";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectSchema<object>>(input: {
@@ -36,52 +36,42 @@ type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
   keyed: {
-    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
-    <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-      readonly source?: never;
-      readonly key?: never;
-    }) | {
-      readonly source: KeyedProjection<string, unknown>;
-      readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-    } : never }, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-      readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-    } ? V_1 | undefined : D[P_1] extends Projection<infer T_1> ? T_1 : never }) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
   } & {
     keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
     values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
+    entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
+    get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
+    groupBy: {
+      <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+      <K extends string, V, const D extends object, G extends string>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, selector: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+    };
+    singleton: <K extends string, V>(source: Projection<V | undefined>, keyOf: (value: V) => Synchronous<K>, equality?: (previous: V, next: V) => boolean) => KeyedProjection<K, V>;
     subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
     filter: {
-      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: V, key: K) => Synchronous<boolean>): KeyedProjection<K, V>;
-      <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-        readonly source?: never;
-        readonly key?: never;
-      }) | {
-        readonly source: KeyedProjection<string, unknown>;
-        readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-      } : never }>(source: KeyedProjection<K, V>, dependencies: D, predicate: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-        readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-      } ? V_1 | undefined : D[P_1] extends Projection<infer T> ? T : never }) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;
     };
     compact: {
-      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
-      <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-        readonly source?: never;
-        readonly key?: never;
-      }) | {
-        readonly source: KeyedProjection<string, unknown>;
-        readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-      } : never }, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-        readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-      } ? V_1 | undefined : D[P_1] extends Projection<infer T_1> ? T_1 : never }) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
     };
   };
 };
 //#endregion
+//#region core/src/projection/readable/keyed.d.ts
+type ProjectionItems<K extends string, V> = {
+  readonly keys: Readable<readonly K[]>;
+  get(key: K): Readable<V | undefined>;
+};
+//#endregion
 //#region core/src/projection/runtime.d.ts
 type ProjectionRuntime = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -99,6 +89,7 @@ type ProjectionScope = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -110,5 +101,5 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { $ as table, A as ParseError, B as DocumentListConfig, C as Read, D as ChangeSet, E as Change, F as CollectionPath, G as ReadonlyValue, H as DocumentTreeValue, I as PathValueOf, J as field, K as Schema, L as SchemaPath, M as parse, N as CollectionEntry, O as MemberChange, P as CollectionId, Q as optional, R as DocumentAddress, S as Draft, T as snapshot, U as Infer, V as DocumentTreeNode, W as ObjectSchema, X as map, Y as list, Z as object, _ as Unsubscribe, a as DocumentProblem, b as CollectionImpact, c as HistoryState, d as OperationResult, et as tree, f as ReadonlyDocument, g as Readable, h as TransactionResult, i as DocumentDisposedError, j as ParseIssue, k as ValueTransition, l as LocalHistory, m as TransactionRejected, n as DocumentCommit, o as DocumentReentrancyError, p as Synchronous, q as Validator, r as DocumentDiagnostic, s as DocumentRuntime, t as CommitSource, tt as variant, u as ObserverError, v as MutationIssue, w as replace, x as DocumentImpact, y as MutationIssueCode, z as DocumentAnchor } from "./contract-COgxO5sv.js";
-import { a as Projection, d as ExternalCollectionRead, f as ExternalCollectionSource, g as ProjectionError, h as ProjectionDisposedError, i as KeyedProjection, m as ExternalValueSource, n as CollectionInputDraft, p as ExternalValueEvent, r as Input, t as CollectionInput, u as ExternalCollectionEvent } from "./definition-xgk3YNBp.js";
+import { _ as ProjectionDisposedError, a as Input, f as ExternalCollectionEvent, g as ExternalValueSource, h as ExternalValueEvent, i as CollectionInputDraft, m as ExternalCollectionSource, n as KeyedDependencyValues, o as KeyedProjection, p as ExternalCollectionRead, r as CollectionInput, s as Projection, t as KeyedDependencies, v as ProjectionError } from "./dependency-BYbdDHNa.js";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectSchema<object>>(input: {
@@ -36,52 +36,42 @@ type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
   keyed: {
-    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
-    <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-      readonly source?: never;
-      readonly key?: never;
-    }) | {
-      readonly source: KeyedProjection<string, unknown>;
-      readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-    } : never }, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-      readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-    } ? V_1 | undefined : D[P_1] extends Projection<infer T_1> ? T_1 : never }) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
   } & {
     keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
     values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
+    entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
+    get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
+    groupBy: {
+      <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+      <K extends string, V, const D extends object, G extends string>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, selector: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+    };
+    singleton: <K extends string, V>(source: Projection<V | undefined>, keyOf: (value: V) => Synchronous<K>, equality?: (previous: V, next: V) => boolean) => KeyedProjection<K, V>;
     subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
     filter: {
-      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: V, key: K) => Synchronous<boolean>): KeyedProjection<K, V>;
-      <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-        readonly source?: never;
-        readonly key?: never;
-      }) | {
-        readonly source: KeyedProjection<string, unknown>;
-        readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-      } : never }>(source: KeyedProjection<K, V>, dependencies: D, predicate: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-        readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-      } ? V_1 | undefined : D[P_1] extends Projection<infer T> ? T : never }) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;
     };
     compact: {
-      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
-      <K extends string, V, const D extends object & { readonly [P in keyof D]: P extends string ? (Projection<unknown> & {
-        readonly source?: never;
-        readonly key?: never;
-      }) | {
-        readonly source: KeyedProjection<string, unknown>;
-        readonly key: (value: V, key: K) => Synchronous<string | undefined>;
-      } : never }, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: { readonly [P_1 in keyof D]: D[P_1] extends {
-        readonly source: KeyedProjection<infer _K extends string, infer V_1>;
-      } ? V_1 | undefined : D[P_1] extends Projection<infer T_1> ? T_1 : never }) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
     };
   };
 };
 //#endregion
+//#region core/src/projection/readable/keyed.d.ts
+type ProjectionItems<K extends string, V> = {
+  readonly keys: Readable<readonly K[]>;
+  get(key: K): Readable<V | undefined>;
+};
+//#endregion
 //#region core/src/projection/runtime.d.ts
 type ProjectionRuntime = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -99,6 +89,7 @@ type ProjectionScope = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -110,5 +101,5 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.ts.map