doxum 0.1.1

package/dist/contract-Otb5W6cQ.d.cts

@@ -0,0 +1,480 @@
+//#region core/src/schema.d.ts
+type DocumentAddress = readonly string[];
+type DocumentListConfig<TItem> = {
+  readonly keyOf: (item: TItem) => string;
+};
+type DocumentTreeNode<TValue> = {
+  readonly parentId?: string;
+  readonly children: readonly string[];
+  readonly value?: TValue;
+};
+type DocumentTreeValue<TValue> = {
+  readonly rootId?: string;
+  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue>>>;
+};
+type BaseNode<K extends string> = {
+  readonly kind: K;
+};
+type FieldNode<T, Optional extends boolean = false> = BaseNode<'field'> & {
+  readonly __value?: T;
+  readonly optional?: Optional;
+};
+type OptionalNode<TNode extends DocumentNode> = TNode & {
+  readonly optional: true;
+};
+interface ObjectShape {
+  readonly [key: string]: DocumentNode;
+}
+type ObjectNode<TShape extends ObjectShape> = BaseNode<'object'> & {
+  readonly shape: TShape;
+};
+interface VariantShape {
+  readonly [key: string]: ObjectNode<ObjectShape>;
+}
+type VariantNode<TTag extends string, TVariants extends VariantShape> = BaseNode<'variant'> & {
+  readonly tag: TTag;
+  readonly variants: TVariants;
+};
+type SingleNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = BaseNode<'single'> & {
+  readonly value: TValue;
+};
+type TableNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = BaseNode<'table'> & {
+  readonly value: TValue;
+};
+type MapNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = BaseNode<'map'> & {
+  readonly value: TValue;
+};
+type RecordNode<TId extends string, TValue> = BaseNode<'record'> & {
+  readonly __id?: TId;
+  readonly __value?: TValue;
+};
+type DictNode<TKey extends string, TValue> = BaseNode<'dict'> & {
+  readonly __key?: TKey;
+  readonly __value?: TValue;
+};
+type ListNode<TItem> = BaseNode<'list'> & {
+  readonly __item?: TItem;
+  keyOf(item: TItem): string;
+};
+type TreeNode<TValue> = BaseNode<'tree'> & {
+  readonly __value?: TValue;
+};
+type DocumentNode = FieldNode<unknown, boolean> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | SingleNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | RecordNode<string, unknown> | DictNode<string, unknown> | ListNode<unknown> | TreeNode<unknown>;
+type EntityValue<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? DocumentValueOfShape<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: { [P in T]: K } & DocumentValueOfShape<V[K] extends ObjectNode<infer S> ? S : never> }[keyof V & string] : never;
+type DocumentValueOfNode<N> = N extends FieldNode<infer T, infer O> ? O extends true ? T | undefined : T : N extends ObjectNode<infer S> ? DocumentValueOfShape<S> : N extends VariantNode<infer T, infer V> ? EntityValue<VariantNode<T, V>> : N extends SingleNode<infer V> ? EntityValue<V> : N extends TableNode<infer V> ? {
+  readonly ids: readonly string[];
+  readonly byId: Readonly<Record<string, EntityValue<V>>>;
+} : N extends MapNode<infer V> ? Readonly<Record<string, EntityValue<V>>> : N extends RecordNode<infer I, infer T> ? Readonly<Record<I, T>> : N extends DictNode<infer K, infer T> ? Readonly<Partial<Record<K, T>>> : N extends ListNode<infer I> ? readonly I[] : N extends TreeNode<infer T> ? DocumentTreeValue<T> : never;
+type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
+  readonly optional: true;
+} ? K : never }[keyof S];
+type RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;
+type DocumentValueOfShape<S extends ObjectShape> = { readonly [K in RequiredKeys<S>]: DocumentValueOfNode<S[K]> } & { readonly [K in OptionalKeys<S>]?: DocumentValueOfNode<S[K]> };
+type ReadonlyDocument<S extends DocumentSchema> = DocumentValueOfShape<S['shape']>;
+type CollectionSelector<TId extends string = string, TEntry = unknown> = {
+  readonly kind: 'collection';
+  readonly schema: DocumentSchema;
+  readonly address: DocumentAddress;
+  readonly __id?: TId;
+  readonly __entry?: TEntry;
+};
+type ValueSelector<TResult = unknown> = {
+  readonly kind: 'value';
+  readonly schema: DocumentSchema;
+  readonly address: DocumentAddress;
+  readonly __value?: TResult;
+};
+type ImpactTarget<T = unknown> = {
+  readonly kind: 'value';
+  readonly at: DocumentAddress;
+} | ValueSelector<T> | {
+  readonly kind: 'collection';
+  readonly at: DocumentAddress;
+  readonly id?: string;
+} | CollectionSelector<string, T>;
+type PathMarker<TValue> = {
+  readonly __value?: TValue;
+};
+type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & {
+  readonly item: (id: string) => SchemaPathFor<{}, unknown>;
+} & PathMarker<TValue>;
+type DocumentSchema<TShape extends ObjectShape = {}> = {
+  readonly kind: 'schema';
+  readonly shape: TShape;
+  collection<TPath extends PathMarker<unknown>>(pick: (path: SchemaPath<TShape>) => TPath): CollectionSelector<CollectionId<TPath>, CollectionEntry<TPath>>;
+  value<TPath extends PathMarker<unknown>>(pick: (path: SchemaPath<TShape>) => TPath): ValueSelector<PathValueResult<TPath>>;
+};
+type SchemaPath<S extends ObjectShape = {}> = SchemaPathFor<S, DocumentValueOfShape<S>>;
+type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
+type VariantFieldPath<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K]> : never : never }[keyof V & string];
+type VariantPath<V extends VariantShape> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & {
+  readonly item: (id: string) => SchemaPathFor<{}, unknown>;
+} & PathMarker<EntityValue<VariantNode<string, V>>>;
+type PathNodeValue<N extends DocumentNode> = N extends {
+  readonly optional: true;
+} ? DocumentValueOfNode<N> | undefined : DocumentValueOfNode<N>;
+type EntityPath<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? SchemaPathFor<S, PathNodeValue<N>> : N extends VariantNode<string, infer V> ? VariantPath<V> : never;
+type CollectionPath<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = Omit<EntityPath<N>, 'item'> & {
+  readonly item: (id: string) => EntityPath<N>;
+  readonly __collection?: {
+    readonly id: string;
+    readonly entry: DocumentValueOfNode<N>;
+  };
+};
+type PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, PathNodeValue<N>> : N extends VariantNode<infer _TTag, infer V> ? VariantPath<V> : N extends TableNode<infer V> | MapNode<infer V> ? CollectionPath<V> : N extends SingleNode<infer V> ? EntityPath<V> : SchemaPathFor<{}, PathNodeValue<N>>;
+type CollectionInfo<T> = T extends {
+  readonly __collection?: {
+    readonly id: infer TId;
+    readonly entry: infer TEntry;
+  };
+} ? {
+  readonly id: TId;
+  readonly entry: TEntry;
+} : never;
+type CollectionId<T> = CollectionInfo<T> extends {
+  readonly id: infer TId extends string;
+} ? TId : string;
+type CollectionEntry<T> = CollectionInfo<T> extends {
+  readonly entry: infer TEntry;
+} ? TEntry : never;
+type PathValueResult<T> = T extends PathMarker<infer TValue> ? TValue : unknown;
+declare const field: <T>() => FieldNode<T>;
+declare const optional: <T extends DocumentNode>(value: T) => OptionalNode<T>;
+declare const object: <S extends ObjectShape>(shape: S) => ObjectNode<S>;
+declare const variant: <T extends string, V extends VariantShape>(tag: T, variants: V) => VariantNode<T, V>;
+declare const single: <V extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>(value: V) => SingleNode<V>;
+declare const table: <V extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>(value: V) => TableNode<V>;
+declare const map: <V extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>(value: V) => MapNode<V>;
+declare const record: <TId extends string = string, TValue = unknown>() => RecordNode<TId, TValue>;
+declare const dict: <TKey extends string = string, TValue = unknown>() => DictNode<TKey, TValue>;
+declare const list: <TItem>(config: DocumentListConfig<TItem>) => ListNode<TItem>;
+declare const tree: <TValue = unknown>() => TreeNode<TValue>;
+declare const schema: <S extends ObjectShape>(shape: S) => DocumentSchema<S>;
+//#endregion
+//#region core/src/operations.d.ts
+type DocumentAnchor = {
+  readonly before: string;
+} | {
+  readonly after: string;
+} | {
+  readonly at: 'start' | 'end';
+};
+type OperationBase = {
+  readonly at: DocumentAddress;
+};
+type FieldSetOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'field.set';
+  readonly value: unknown;
+};
+type FieldClearOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'field.clear';
+};
+type VariantReplaceOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'variant.replace';
+  readonly value: unknown;
+};
+type DictSetOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'dict.set';
+  readonly key: string;
+  readonly value: unknown;
+};
+type DictDeleteOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'dict.delete';
+  readonly key: string;
+};
+type DictReplaceOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'dict.replace';
+  readonly value: Readonly<Record<string, unknown>>;
+};
+type EntityCreateOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'entity.create';
+  readonly entries: readonly EntityEntry[];
+  readonly anchor?: DocumentAnchor; /** Generated inverse metadata with strictly increasing final indices. Normal creates omit it. */
+  readonly positions?: readonly number[];
+};
+type EntityEntry = {
+  readonly id: string;
+  readonly value: unknown;
+};
+type EntityRemoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'entity.remove';
+  readonly ids: readonly string[];
+};
+type EntityMoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'entity.move';
+  readonly id: string;
+  readonly anchor?: DocumentAnchor;
+};
+type ListInsertOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'list.insert';
+  readonly key: string;
+  readonly value: unknown;
+  readonly anchor?: DocumentAnchor;
+};
+type ListMoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'list.move';
+  readonly key: string;
+  readonly anchor?: DocumentAnchor;
+};
+type ListRemoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'list.remove';
+  readonly key: string;
+};
+type ListReplaceOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'list.replace';
+  readonly value: readonly unknown[];
+  readonly keys: readonly string[];
+};
+type TreeInsertOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'tree.insert';
+  readonly treeNodeId: string;
+  readonly parentId?: string;
+  readonly index?: number;
+  readonly value?: unknown;
+};
+type TreeMoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'tree.move';
+  readonly treeNodeId: string;
+  readonly parentId?: string;
+  readonly index?: number;
+};
+type TreeRemoveOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'tree.remove';
+  readonly treeNodeId: string;
+};
+type TreeSetOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'tree.set';
+  readonly treeNodeId: string;
+  readonly value: unknown;
+};
+type TreeReplaceOperation<TSchema extends DocumentSchema = DocumentSchema> = OperationBase & {
+  readonly type: 'tree.replace';
+  readonly value: unknown;
+};
+type DocumentOperationUnion<TSchema extends DocumentSchema = DocumentSchema> = FieldSetOperation<TSchema> | FieldClearOperation<TSchema> | VariantReplaceOperation<TSchema> | DictSetOperation<TSchema> | DictDeleteOperation<TSchema> | DictReplaceOperation<TSchema> | EntityCreateOperation<TSchema> | EntityRemoveOperation<TSchema> | EntityMoveOperation<TSchema> | ListInsertOperation<TSchema> | ListMoveOperation<TSchema> | ListRemoveOperation<TSchema> | ListReplaceOperation<TSchema> | TreeInsertOperation<TSchema> | TreeMoveOperation<TSchema> | TreeRemoveOperation<TSchema> | TreeSetOperation<TSchema> | TreeReplaceOperation<TSchema>;
+type DocumentOperation<TSchema extends DocumentSchema = DocumentSchema> = DocumentOperationUnion<TSchema>;
+//#endregion
+//#region core/src/access/reader.d.ts
+type FieldReader<T> = {
+  readonly get: () => T;
+};
+type CollectionReader<TId, TEntry> = {
+  readonly ids: () => readonly TId[];
+  readonly has: (id: TId) => boolean;
+  readonly get: (id: TId) => EntityReader<TEntry> | undefined;
+};
+type ListReader<T> = {
+  readonly values: () => readonly T[];
+  readonly length: () => number;
+  readonly at: (index: number) => T | undefined;
+};
+type TreeReader<T> = {
+  readonly rootId: () => string | undefined;
+  readonly has: (id: string) => boolean;
+  readonly value: (id: string) => T | undefined;
+  readonly parent: (id: string) => string | undefined;
+  readonly children: (id: string) => readonly string[];
+};
+type EntityReader<T> = T extends object ? { readonly [K in keyof T]: ReaderValue<T[K]> } : FieldReader<T>;
+type ReaderValue<T> = T extends readonly (infer TItem)[] ? ListReader<TItem> : T extends object ? EntityReader<T> : FieldReader<T>;
+type ReaderOfNode<TNode extends DocumentNode> = TNode extends {
+  kind: 'field';
+} ? FieldReader<DocumentValueOfNode<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: ReaderOfNode<TShape[K]> } : TNode extends VariantNode<string, infer TVariants> ? { readonly [K in keyof TVariants]: ReaderOfNode<TVariants[K]> } : TNode extends SingleNode<infer TValue> ? ReaderOfNode<TValue> : TNode extends TableNode<infer TValue> ? CollectionReader<string, DocumentValueOfNode<TValue>> : TNode extends MapNode<infer TValue> ? CollectionReader<string, DocumentValueOfNode<TValue>> : TNode extends DictNode<infer TKey, infer TValue> ? FieldReader<Readonly<Partial<Record<TKey, TValue>>>> : TNode extends ListNode<infer TItem> ? ListReader<TItem> : TNode extends TreeNode<infer TValue> ? TreeReader<TValue> : FieldReader<DocumentValueOfNode<TNode>>;
+type DocumentReader<TSchema extends DocumentSchema> = ReaderOfNode<ObjectNode<TSchema['shape']>>;
+//#endregion
+//#region core/src/access/writer.d.ts
+type FieldWriter<T> = {
+  readonly set: (value: T) => void;
+  readonly clear?: () => void;
+};
+type DictionaryWriter<TKey extends string, TValue> = {
+  readonly set: (key: TKey, value: TValue) => void;
+  readonly delete: (key: TKey) => void;
+  readonly replace: (value: Readonly<Partial<Record<TKey, TValue>>>) => void;
+};
+type CollectionWriter<TId, TEntry> = {
+  readonly create: (entry: {
+    readonly id: TId;
+    readonly value: TEntry;
+  } | readonly {
+    readonly id: TId;
+    readonly value: TEntry;
+  }[], anchor?: DocumentAnchor) => void;
+  readonly item: (id: TId) => EntityWriter<TEntry>;
+  readonly remove: (id: TId | readonly TId[]) => void;
+  readonly move: (id: TId, anchor?: DocumentAnchor) => void;
+};
+type MapWriter<TId, TEntry> = {
+  readonly create: (entry: {
+    readonly id: TId;
+    readonly value: TEntry;
+  } | readonly {
+    readonly id: TId;
+    readonly value: TEntry;
+  }[]) => void;
+  readonly item: (id: TId) => EntityWriter<TEntry>;
+  readonly remove: (id: TId | readonly TId[]) => void;
+};
+type ListWriter<T> = {
+  readonly insert: (value: T, anchor?: DocumentAnchor) => void;
+  readonly move: (key: string, anchor?: DocumentAnchor) => void;
+  readonly remove: (key: string) => void;
+  readonly replace: (value: readonly T[]) => void;
+};
+type TreeWriter<T> = {
+  readonly insert: (id: string, value: T, parentId?: string, index?: number) => void;
+  readonly move: (id: string, parentId?: string, index?: number) => void;
+  readonly remove: (id: string) => void;
+  readonly set: (id: string, value: T) => void;
+  readonly replace: (value: unknown) => void;
+};
+type EntityWriter<T> = T extends object ? { readonly [K in keyof T]: WriterValue<T[K]> } : FieldWriter<T>;
+type WriterValue<T> = T extends readonly (infer TItem)[] ? ListWriter<TItem> : T extends object ? EntityWriter<T> : FieldWriter<T>;
+type WriterOfNode<TNode extends DocumentNode> = TNode extends {
+  kind: 'field';
+} ? FieldWriter<DocumentValueOfNode<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: WriterOfNode<TShape[K]> } : TNode extends VariantNode<string, infer _TVariants> ? {
+  readonly replace: (value: DocumentValueOfNode<TNode>) => void;
+} : TNode extends SingleNode<infer TValue> ? WriterOfNode<TValue> : TNode extends TableNode<infer TValue> ? CollectionWriter<string, DocumentValueOfNode<TValue>> : TNode extends MapNode<infer TValue> ? MapWriter<string, DocumentValueOfNode<TValue>> : TNode extends DictNode<infer TKey, infer TValue> ? DictionaryWriter<TKey, TValue> : TNode extends ListNode<infer TItem> ? ListWriter<TItem> : TNode extends TreeNode<infer TValue> ? TreeWriter<TValue> : FieldWriter<DocumentValueOfNode<TNode>>;
+type DocumentWriter<TSchema extends DocumentSchema> = WriterOfNode<ObjectNode<TSchema['shape']>>;
+//#endregion
+//#region core/src/mutation/issue.d.ts
+type MutationIssueCode = 'invalid-address' | 'invalid-operation' | 'unknown-operation' | 'required-field' | 'invalid-anchor' | 'duplicate-entity' | 'missing-entity' | 'invalid-collection' | 'invalid-list-keys' | 'invalid-list-key' | 'duplicate-list-item' | 'missing-list-item' | 'invalid-tree' | 'duplicate-tree-node' | 'missing-tree-parent' | 'invalid-tree-index' | 'missing-tree-node' | 'tree-cycle';
+type MutationIssue = {
+  readonly source: 'mutation';
+  readonly code: MutationIssueCode;
+  readonly address: DocumentAddress;
+  readonly message: string;
+  readonly operation?: DocumentOperationUnion['type'];
+};
+//#endregion
+//#region core/src/impact.d.ts
+type CollectionImpact<TId> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: ReadonlySet<TId>;
+  readonly removed: ReadonlySet<TId>;
+  readonly updated: ReadonlySet<TId>;
+  readonly orderChanged: boolean;
+};
+type DocumentImpact<TSchema extends DocumentSchema> = {
+  readonly kind: 'incremental' | 'reset';
+  readonly affects: (target: ImpactTarget<unknown>) => boolean;
+  readonly collection: <TId extends string, TEntry>(selector: CollectionSelector<TId, TEntry>) => CollectionImpact<TId>;
+  readonly operations: readonly DocumentOperationUnion<TSchema>[];
+};
+//#endregion
+//#region core/src/address.d.ts
+/** The only resolved address representation used inside the runtime. */
+type AddressRef = {
+  readonly path: number;
+  readonly address: DocumentAddress;
+};
+declare const resolveAddress: (schema: DocumentSchema, address: DocumentAddress, document?: unknown) => AddressRef | undefined;
+declare const read: (root: unknown, address: DocumentAddress) => unknown;
+declare const contains: (parent: DocumentAddress, child: DocumentAddress) => boolean;
+declare const overlaps: (a: DocumentAddress, b: DocumentAddress) => boolean;
+declare const debugKey: (address: DocumentAddress) => string;
+//#endregion
+//#region core/src/runtime/contract.d.ts
+type Unsubscribe = () => void;
+type CommitSource = 'local' | 'system' | 'history' | 'remote';
+declare class DocumentReentrancyError extends Error {
+  constructor();
+}
+declare class DocumentDisposedError extends Error {
+  constructor();
+}
+type DocumentCommit<TSchema extends DocumentSchema> = {
+  readonly revision: number;
+  readonly kind: 'operations' | 'replace';
+  readonly source: CommitSource;
+  readonly operations: readonly DocumentOperationUnion<TSchema>[];
+  readonly inverse: readonly DocumentOperationUnion<TSchema>[];
+  readonly impact: DocumentImpact<TSchema>;
+};
+type DocumentDiagnostic = {
+  readonly source: 'application';
+  readonly code: string;
+  readonly message: string;
+  readonly address?: DocumentAddress;
+};
+type DocumentProblem = DocumentDiagnostic | MutationIssue;
+type ObserverError = {
+  readonly phase: 'processor' | 'flush' | 'listener';
+  readonly error: unknown;
+};
+type TransactionResult<TValue, TCommit> = {
+  readonly status: 'committed';
+  readonly value: TValue;
+  readonly commit: TCommit;
+  readonly reports: readonly DocumentDiagnostic[];
+  readonly observerErrors: readonly ObserverError[];
+} | {
+  readonly status: 'unchanged';
+  readonly value: TValue;
+  readonly revision: number;
+  readonly reports: readonly DocumentDiagnostic[];
+} | {
+  readonly status: 'rejected';
+  readonly issues: readonly DocumentProblem[];
+  readonly revision: number;
+};
+type OperationResult<TCommit> = {
+  readonly status: 'committed';
+  readonly commit: TCommit;
+  readonly observerErrors: readonly ObserverError[];
+} | {
+  readonly status: 'unchanged';
+  readonly revision: number;
+} | {
+  readonly status: 'rejected';
+  readonly issues: readonly MutationIssue[];
+  readonly revision: number;
+};
+type HistoryState = {
+  readonly undoDepth: number;
+  readonly redoDepth: number;
+};
+type LocalHistory<TCommit> = {
+  current(): HistoryState;
+  subscribe(listener: () => void): Unsubscribe;
+  undo(): OperationResult<TCommit>;
+  redo(): OperationResult<TCommit>;
+  clear(): void;
+};
+type DocumentTransaction<TSchema extends DocumentSchema> = {
+  readonly read: DocumentReader<TSchema>;
+  readonly write: DocumentWriter<TSchema>;
+  readonly reject: (issue: DocumentDiagnostic | readonly DocumentDiagnostic[]) => never;
+  readonly report: (issue: DocumentDiagnostic) => void;
+};
+type CommitListener<TSchema extends DocumentSchema> = (commit: DocumentCommit<TSchema>) => void;
+type DocumentRuntime<TSchema extends DocumentSchema> = {
+  readonly address: {
+    readonly resolve: (address: DocumentAddress) => AddressRef | undefined;
+    readonly read: (address: DocumentAddress) => unknown;
+    readonly contains: (parent: DocumentAddress, child: DocumentAddress) => boolean;
+    readonly overlaps: (left: DocumentAddress, right: DocumentAddress) => boolean;
+    readonly debugKey: (address: DocumentAddress) => string;
+  };
+  revision(): number;
+  update<TResult>(run: (transaction: DocumentTransaction<TSchema>) => TResult, options?: {
+    readonly source?: Extract<CommitSource, 'local' | 'system'>;
+    readonly history?: boolean;
+  }): TransactionResult<TResult, DocumentCommit<TSchema>>;
+  apply(operations: unknown, options?: {
+    readonly source?: Exclude<CommitSource, 'history'>;
+    readonly history?: boolean;
+  }): OperationResult<DocumentCommit<TSchema>>;
+  replace(document: ReadonlyDocument<TSchema>, options?: {
+    readonly source?: Extract<CommitSource, 'system' | 'remote'>;
+  }): OperationResult<DocumentCommit<TSchema>>;
+  subscribe(listener: CommitListener<TSchema>): Unsubscribe;
+  subscribe(target: ImpactTarget<unknown> | readonly [ImpactTarget<unknown>, ...ImpactTarget<unknown>[]], listener: CommitListener<TSchema>): Unsubscribe;
+  readonly history: LocalHistory<DocumentCommit<TSchema>>;
+  dispose(): void;
+};
+//#endregion
+export { ListInsertOperation as $, ListWriter as A, TableNode as At, TreeReader as B, optional as Bt, MutationIssue as C, ObjectNode as Ct, DocumentWriter as D, RecordNode as Dt, DictionaryWriter as E, ReadonlyDocument as Et, DocumentReader as F, dict as Ft, DocumentOperation as G, tree as Gt, DictReplaceOperation as H, schema as Ht, EntityReader as I, field as It, EntityEntry as J, DocumentOperationUnion as K, variant as Kt, FieldReader as L, list as Lt, TreeWriter as M, ValueSelector as Mt, WriterOfNode as N, VariantNode as Nt, EntityWriter as O, SchemaPath as Ot, CollectionReader as P, VariantShape as Pt, FieldSetOperation as Q, ListReader as R, map as Rt, DocumentImpact as S, MapNode as St, CollectionWriter as T, OptionalNode as Tt, DictSetOperation as U, single as Ut, DictDeleteOperation as V, record as Vt, DocumentAnchor as W, table as Wt, EntityRemoveOperation as X, EntityMoveOperation as Y, FieldClearOperation as Z, debugKey as _, DocumentValueOfNode as _t, DocumentProblem as a, TreeRemoveOperation as at, resolveAddress as b, ImpactTarget as bt, DocumentTransaction as c, VariantReplaceOperation as ct, ObserverError as d, DocumentAddress as dt, ListMoveOperation as et, OperationResult as f, DocumentListConfig as ft, contains as g, DocumentTreeValue as gt, AddressRef as h, DocumentTreeNode as ht, DocumentDisposedError as i, TreeMoveOperation as it, MapWriter as j, TreeNode as jt, FieldWriter as k, SingleNode as kt, HistoryState as l, CollectionSelector as lt, Unsubscribe as m, DocumentSchema as mt, DocumentCommit as n, ListReplaceOperation as nt, DocumentReentrancyError as o, TreeReplaceOperation as ot, TransactionResult as p, DocumentNode as pt, EntityCreateOperation as q, DocumentDiagnostic as r, TreeInsertOperation as rt, DocumentRuntime as s, TreeSetOperation as st, CommitSource as t, ListRemoveOperation as tt, LocalHistory as u, DictNode as ut, overlaps as v, DocumentValueOfShape as vt, MutationIssueCode as w, ObjectShape as wt, CollectionImpact as x, ListNode as xt, read as y, FieldNode as yt, ReaderOfNode as z, object as zt };
+//# sourceMappingURL=contract-Otb5W6cQ.d.cts.map