@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/index.d.mts

@@ -0,0 +1,1086 @@
+import { Schema } from "effect";
+import * as Schema$1 from "effect/Schema";
+
+//#region src/OperationPath.d.ts
+declare namespace OperationPath_d_exports {
+  export { EncodedOperationPath, OperationPath, OperationPathToken, decode$2 as decode, encode$2 as encode, fromTokens, getRelativePath, isPrefix, make$4 as make, pathsEqual, pathsOverlap };
+}
+type OperationPathToken = string;
+interface OperationPath {
+  readonly _tag: "OperationPath";
+  readonly toTokens: () => ReadonlyArray<OperationPathToken>;
+  readonly concat: (other: OperationPath) => OperationPath;
+  readonly append: (token: OperationPathToken) => OperationPath;
+  readonly pop: () => OperationPath;
+  readonly shift: () => OperationPath;
+}
+/**
+ * Creates a new operation path.
+ * @param stringPath - The string path to create the path from.
+ * @returns The new operation path.
+ */
+declare function make$4(stringPath?: string): OperationPath;
+/**
+ * Creates a new operation path from tokens.
+ * @param tokens - The tokens to create the path from.
+ * @returns The new operation path.
+ */
+declare function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath;
+/**
+ * Checks if two operation paths overlap (one is prefix of the other or equal).
+ */
+declare const pathsOverlap: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+ */
+declare const isPrefix: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if two paths are exactly equal.
+ */
+declare const pathsEqual: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Gets the relative path of pathB with respect to pathA.
+ * Assumes pathA is a prefix of pathB.
+ */
+declare const getRelativePath: (basePath: OperationPath, fullPath: OperationPath) => string[];
+/**
+ * Encoded representation of an OperationPath for network transport.
+ */
+type EncodedOperationPath = string;
+/**
+ * Encodes an OperationPath to a string for network transport.
+ * @param path - The operation path to encode.
+ * @returns The encoded string representation.
+ */
+declare const encode$2: (path: OperationPath) => EncodedOperationPath;
+/**
+ * Decodes an encoded string back to an OperationPath.
+ * @param encoded - The encoded string representation.
+ * @returns The decoded OperationPath.
+ */
+declare const decode$2: (encoded: EncodedOperationPath) => OperationPath;
+//#endregion
+//#region src/OperationDefinition.d.ts
+interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {
+  readonly kind: TKind;
+  readonly payload: TPayload;
+  readonly target: TTarget;
+}
+declare namespace Operation_d_exports {
+  export { EncodedOperation, Operation, decode$1 as decode, encode$1 as encode, fromDefinition };
+}
+type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>> = {
+  readonly kind: TKind;
+  readonly path: OperationPath;
+  readonly payload: Schema.Schema.Type<TPayload>;
+} & TDef;
+declare const fromDefinition: <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>) => Operation<TKind, TPayload, TDef>;
+/**
+ * Encoded representation of an Operation for network transport.
+ */
+interface EncodedOperation {
+  readonly kind: unknown;
+  readonly path: EncodedOperationPath;
+  readonly payload: unknown;
+}
+/**
+ * Encodes an Operation to a JSON-serializable format for network transport.
+ * @param operation - The operation to encode.
+ * @returns The encoded representation.
+ */
+declare const encode$1: <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>>(operation: Operation<TKind, TPayload, TDef>) => EncodedOperation;
+/**
+ * Decodes an encoded operation back to an Operation.
+ * Note: This returns a partial operation without the definition methods.
+ * The caller must have the operation definitions to fully reconstruct if needed.
+ * @param encoded - The encoded representation.
+ * @returns The decoded Operation (without definition-specific methods).
+ */
+declare const decode$1: (encoded: EncodedOperation) => Operation<unknown, Schema.Schema.Any, any>;
+declare namespace ProxyEnvironment_d_exports {
+  export { ProxyEnvironment, ProxyEnvironmentOptions, make$3 as make };
+}
+type ProxyEnvironment = {
+  /** Adds an operation to be collected/applied */
+  readonly addOperation: (operation: Operation<any, any, any>) => void;
+  /** Gets the current state at the given path */
+  readonly getState: (path: OperationPath) => unknown;
+  /** Generates a unique ID (UUID) for array elements */
+  readonly generateId: () => string;
+};
+interface ProxyEnvironmentOptions {
+  /** Callback when an operation is added */
+  readonly onOperation: (operation: Operation<any, any, any>) => void;
+  /** Function to retrieve current state at a path (defaults to returning undefined) */
+  readonly getState?: (path: OperationPath) => unknown;
+  /** Optional: Custom ID generator (defaults to crypto.randomUUID) */
+  readonly generateId?: () => string;
+}
+/**
+ * Creates a ProxyEnvironment.
+ * @param optionsOrCallback - Either an options object or a simple callback for operations
+ */
+declare const make$3: (optionsOrCallback: ProxyEnvironmentOptions | ((operation: Operation<any, any, any>) => void)) => ProxyEnvironment;
+declare namespace Transform_d_exports {
+  export { TransformResult };
+}
+/**
+ * Result of transforming an operation against another operation.
+ */
+type TransformResult = {
+  type: "transformed";
+  operation: Operation<any, any, any>;
+} | {
+  type: "noop";
+} | {
+  type: "conflict";
+  reason: string;
+};
+//#endregion
+//#region src/primitives/shared.d.ts
+/**
+ * Base interface that all primitives must implement.
+ * Provides type inference helpers and internal operations.
+ */
+interface Primitive<TState, TProxy> {
+  readonly _tag: string;
+  readonly _State: TState;
+  readonly _Proxy: TProxy;
+  readonly _internal: PrimitiveInternal<TState, TProxy>;
+}
+/**
+ * Internal operations that each primitive must provide.
+ */
+interface PrimitiveInternal<TState, TProxy> {
+  /** Creates a proxy for generating operations */
+  readonly createProxy: (env: ProxyEnvironment, path: OperationPath) => TProxy;
+  /** Applies an operation to the current state, returning the new state */
+  readonly applyOperation: (state: TState | undefined, operation: Operation<any, any, any>) => TState;
+  /** Returns the initial/default state for this primitive */
+  readonly getInitialState: () => TState | undefined;
+  /**
+   * Transforms a client operation against a server operation.
+   * Used for operational transformation (OT) conflict resolution.
+   *
+   * @param clientOp - The client's operation to transform
+   * @param serverOp - The server's operation that has already been applied
+   * @returns TransformResult indicating how the client operation should be handled
+   */
+  readonly transformOperation: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>) => TransformResult;
+}
+/**
+ * Any primitive type - used for generic constraints.
+ */
+type AnyPrimitive = Primitive<any, any>;
+/**
+ * Infer the state type from a primitive.
+ */
+type InferState<T> = T extends Primitive<infer S, any> ? S : never;
+/**
+ * Infer the proxy type from a primitive.
+ */
+type InferProxy<T> = T extends Primitive<any, infer P> ? P : never;
+/**
+ * Helper type to conditionally add undefined based on TDefined.
+ * When TDefined is true, the value is guaranteed to be defined (via required() or default()).
+ * When TDefined is false, the value may be undefined.
+ */
+type MaybeUndefined<T, TDefined extends boolean> = TDefined extends true ? T : T | undefined;
+/**
+ * Infer the snapshot type from a primitive.
+ * The snapshot is a readonly, type-safe structure suitable for rendering.
+ */
+type InferSnapshot<T> = T extends Primitive<any, infer P> ? P extends {
+  toSnapshot(): infer S;
+} ? S : never : never;
+declare class ValidationError extends Error {
+  readonly _tag = "ValidationError";
+  constructor(message: string);
+}
+/**
+ * A validator that checks a value and returns whether it's valid.
+ */
+interface Validator<T> {
+  readonly validate: (value: T) => boolean;
+  readonly message: string;
+}
+/**
+ * Runs all validators against a value, throwing ValidationError if any fail.
+ */
+declare function runValidators<T>(value: T, validators: readonly {
+  validate: (value: T) => boolean;
+  message: string;
+}[]): void;
+/**
+ * Checks if an operation is compatible with the given operation definitions.
+ * @param operation - The operation to check.
+ * @param operationDefinitions - The operation definitions to check against.
+ * @returns True if the operation is compatible, false otherwise.
+ */
+declare function isCompatibleOperation(operation: Operation<any, any, any>, operationDefinitions: Record<string, OperationDefinition<any, any, any>>): boolean;
+//#endregion
+//#region src/primitives/String.d.ts
+interface StringProxy<TDefined extends boolean = false> {
+  /** Gets the current string value */
+  get(): MaybeUndefined<string, TDefined>;
+  /** Sets the string value, generating a string.set operation */
+  set(value: string): void;
+  /** Returns a readonly snapshot of the string value for rendering */
+  toSnapshot(): MaybeUndefined<string, TDefined>;
+}
+interface StringPrimitiveSchema {
+  readonly required: boolean;
+  readonly defaultValue: string | undefined;
+  readonly validators: readonly Validator<string>[];
+}
+declare class StringPrimitive<TDefined extends boolean = false> implements Primitive<string, StringProxy<TDefined>> {
+  readonly _tag: "StringPrimitive";
+  readonly _State: string;
+  readonly _Proxy: StringProxy<TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: StringPrimitiveSchema);
+  /** Mark this string as required */
+  required(): StringPrimitive<true>;
+  /** Set a default value for this string */
+  default(defaultValue: string): StringPrimitive<true>;
+  /** Add a custom validation rule */
+  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TDefined>;
+  /** Minimum string length */
+  min(length: number): StringPrimitive<TDefined>;
+  /** Maximum string length */
+  max(length: number): StringPrimitive<TDefined>;
+  /** Exact string length */
+  length(exact: number): StringPrimitive<TDefined>;
+  /** Match a regex pattern */
+  regex(pattern: RegExp, message?: string): StringPrimitive<TDefined>;
+  /** Validate as email format */
+  email(): StringPrimitive<TDefined>;
+  /** Validate as URL format */
+  url(): StringPrimitive<TDefined>;
+  readonly _internal: PrimitiveInternal<string, StringProxy<TDefined>>;
+}
+/** Creates a new StringPrimitive */
+declare const String: () => StringPrimitive<false>;
+//#endregion
+//#region src/primitives/Struct.d.ts
+/**
+ * Maps a schema definition to its state type.
+ * { name: StringPrimitive, age: NumberPrimitive } -> { name: string, age: number }
+ */
+type InferStructState<TFields extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields]: InferState<TFields[K]> };
+/**
+ * Maps a schema definition to its snapshot type.
+ * Each field's snapshot type is inferred from the field primitive.
+ */
+type InferStructSnapshot<TFields extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields]: InferSnapshot<TFields[K]> };
+/**
+ * Maps a schema definition to its proxy type.
+ * Provides nested field access + get()/set()/toSnapshot() methods for the whole struct.
+ */
+type StructProxy<TFields extends Record<string, AnyPrimitive>, TDefined extends boolean = false> = { readonly [K in keyof TFields]: InferProxy<TFields[K]> } & {
+  /** Gets the entire struct value */
+  get(): MaybeUndefined<InferStructState<TFields>, TDefined>;
+  /** Sets the entire struct value */
+  set(value: InferStructState<TFields>): void;
+  /** Returns a readonly snapshot of the struct for rendering */
+  toSnapshot(): MaybeUndefined<InferStructSnapshot<TFields>, TDefined>;
+};
+interface StructPrimitiveSchema<TFields extends Record<string, AnyPrimitive>> {
+  readonly required: boolean;
+  readonly defaultValue: InferStructState<TFields> | undefined;
+  readonly fields: TFields;
+  readonly validators: readonly Validator<InferStructState<TFields>>[];
+}
+declare class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefined extends boolean = false> implements Primitive<InferStructState<TFields>, StructProxy<TFields, TDefined>> {
+  readonly _tag: "StructPrimitive";
+  readonly _State: InferStructState<TFields>;
+  readonly _Proxy: StructProxy<TFields, TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: StructPrimitiveSchema<TFields>);
+  /** Mark this struct as required */
+  required(): StructPrimitive<TFields, true>;
+  /** Set a default value for this struct */
+  default(defaultValue: InferStructState<TFields>): StructPrimitive<TFields, true>;
+  /** Get the fields schema */
+  get fields(): TFields;
+  /** Add a custom validation rule (useful for cross-field validation) */
+  refine(fn: (value: InferStructState<TFields>) => boolean, message: string): StructPrimitive<TFields, TDefined>;
+  readonly _internal: PrimitiveInternal<InferStructState<TFields>, StructProxy<TFields, TDefined>>;
+}
+/** Creates a new StructPrimitive with the given fields */
+declare const Struct: <TFields extends Record<string, AnyPrimitive>>(fields: TFields) => StructPrimitive<TFields, false>;
+//#endregion
+//#region src/primitives/Boolean.d.ts
+interface BooleanProxy<TDefined extends boolean = false> {
+  /** Gets the current boolean value */
+  get(): MaybeUndefined<boolean, TDefined>;
+  /** Sets the boolean value, generating a boolean.set operation */
+  set(value: boolean): void;
+  /** Returns a readonly snapshot of the boolean value for rendering */
+  toSnapshot(): MaybeUndefined<boolean, TDefined>;
+}
+interface BooleanPrimitiveSchema {
+  readonly required: boolean;
+  readonly defaultValue: boolean | undefined;
+  readonly validators: readonly Validator<boolean>[];
+}
+declare class BooleanPrimitive<TDefined extends boolean = false> implements Primitive<boolean, BooleanProxy<TDefined>> {
+  readonly _tag: "BooleanPrimitive";
+  readonly _State: boolean;
+  readonly _Proxy: BooleanProxy<TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: BooleanPrimitiveSchema);
+  /** Mark this boolean as required */
+  required(): BooleanPrimitive<true>;
+  /** Set a default value for this boolean */
+  default(defaultValue: boolean): BooleanPrimitive<true>;
+  /** Add a custom validation rule */
+  refine(fn: (value: boolean) => boolean, message: string): BooleanPrimitive<TDefined>;
+  readonly _internal: PrimitiveInternal<boolean, BooleanProxy<TDefined>>;
+}
+/** Creates a new BooleanPrimitive */
+declare const Boolean: () => BooleanPrimitive<false>;
+//#endregion
+//#region src/primitives/Number.d.ts
+interface NumberProxy<TDefined extends boolean = false> {
+  /** Gets the current number value */
+  get(): MaybeUndefined<number, TDefined>;
+  /** Sets the number value, generating a number.set operation */
+  set(value: number): void;
+  /** Returns a readonly snapshot of the number value for rendering */
+  toSnapshot(): MaybeUndefined<number, TDefined>;
+}
+interface NumberPrimitiveSchema {
+  readonly required: boolean;
+  readonly defaultValue: number | undefined;
+  readonly validators: readonly Validator<number>[];
+}
+declare class NumberPrimitive<TDefined extends boolean = false> implements Primitive<number, NumberProxy<TDefined>> {
+  readonly _tag: "NumberPrimitive";
+  readonly _State: number;
+  readonly _Proxy: NumberProxy<TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: NumberPrimitiveSchema);
+  /** Mark this number as required */
+  required(): NumberPrimitive<true>;
+  /** Set a default value for this number */
+  default(defaultValue: number): NumberPrimitive<true>;
+  /** Add a custom validation rule */
+  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TDefined>;
+  /** Minimum value (inclusive) */
+  min(value: number): NumberPrimitive<TDefined>;
+  /** Maximum value (inclusive) */
+  max(value: number): NumberPrimitive<TDefined>;
+  /** Must be positive (> 0) */
+  positive(): NumberPrimitive<TDefined>;
+  /** Must be negative (< 0) */
+  negative(): NumberPrimitive<TDefined>;
+  /** Must be an integer */
+  int(): NumberPrimitive<TDefined>;
+  readonly _internal: PrimitiveInternal<number, NumberProxy<TDefined>>;
+}
+/** Creates a new NumberPrimitive */
+declare const Number: () => NumberPrimitive<false>;
+//#endregion
+//#region src/primitives/Literal.d.ts
+/** Valid literal types */
+type LiteralValue = string | number | boolean | null;
+interface LiteralProxy<T extends LiteralValue, TDefined extends boolean = false> {
+  /** Gets the current literal value */
+  get(): MaybeUndefined<T, TDefined>;
+  /** Sets the literal value (must match the exact literal type) */
+  set(value: T): void;
+  /** Returns a readonly snapshot of the literal value for rendering */
+  toSnapshot(): MaybeUndefined<T, TDefined>;
+}
+interface LiteralPrimitiveSchema<T extends LiteralValue> {
+  readonly required: boolean;
+  readonly defaultValue: T | undefined;
+  readonly literal: T;
+}
+declare class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean = false> implements Primitive<T, LiteralProxy<T, TDefined>> {
+  readonly _tag: "LiteralPrimitive";
+  readonly _State: T;
+  readonly _Proxy: LiteralProxy<T, TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: LiteralPrimitiveSchema<T>);
+  /** Mark this literal as required */
+  required(): LiteralPrimitive<T, true>;
+  /** Set a default value for this literal */
+  default(defaultValue: T): LiteralPrimitive<T, true>;
+  /** Get the literal value this primitive represents */
+  get literal(): T;
+  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TDefined>>;
+}
+/** Creates a new LiteralPrimitive with the given literal value */
+declare const Literal: <T extends LiteralValue>(literal: T) => LiteralPrimitive<T, false>;
+//#endregion
+//#region src/primitives/Array.d.ts
+/**
+ * Entry in an ordered array with ID and fractional position
+ */
+interface ArrayEntry<T> {
+  readonly id: string;
+  readonly pos: string;
+  readonly value: T;
+}
+/**
+ * Entry in an array snapshot with ID and value snapshot
+ */
+interface ArrayEntrySnapshot<TElement extends AnyPrimitive> {
+  readonly id: string;
+  readonly value: InferSnapshot<TElement>;
+}
+/**
+ * Snapshot type for arrays - always an array (never undefined)
+ */
+type ArraySnapshot<TElement extends AnyPrimitive> = readonly ArrayEntrySnapshot<TElement>[];
+interface ArrayProxy<TElement extends AnyPrimitive> {
+  /** Gets the current array entries (sorted by position) */
+  get(): ArrayState<TElement>;
+  /** Replaces the entire array with new values (generates new IDs and positions) */
+  set(values: readonly InferState<TElement>[]): void;
+  /** Appends a value to the end of the array */
+  push(value: InferState<TElement>): void;
+  /** Inserts a value at the specified visual index */
+  insertAt(index: number, value: InferState<TElement>): void;
+  /** Removes the element with the specified ID */
+  remove(id: string): void;
+  /** Moves an element to a new visual index */
+  move(id: string, toIndex: number): void;
+  /** Returns a proxy for the element with the specified ID */
+  at(id: string): InferProxy<TElement>;
+  /** Finds an element by predicate and returns its proxy */
+  find(predicate: (value: InferState<TElement>, id: string) => boolean): InferProxy<TElement> | undefined;
+  /** Returns a readonly snapshot of the array for rendering (always returns an array, never undefined) */
+  toSnapshot(): ArraySnapshot<TElement>;
+}
+/** The state type for arrays - an array of entries */
+type ArrayState<TElement extends AnyPrimitive> = readonly ArrayEntry<InferState<TElement>>[];
+interface ArrayPrimitiveSchema<TElement extends AnyPrimitive> {
+  readonly required: boolean;
+  readonly defaultValue: ArrayState<TElement> | undefined;
+  readonly element: TElement;
+  readonly validators: readonly Validator<ArrayState<TElement>>[];
+}
+declare class ArrayPrimitive<TElement extends AnyPrimitive> implements Primitive<ArrayState<TElement>, ArrayProxy<TElement>> {
+  readonly _tag: "ArrayPrimitive";
+  readonly _State: ArrayState<TElement>;
+  readonly _Proxy: ArrayProxy<TElement>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: ArrayPrimitiveSchema<TElement>);
+  /** Mark this array as required */
+  required(): ArrayPrimitive<TElement>;
+  /** Set a default value for this array */
+  default(defaultValue: ArrayState<TElement>): ArrayPrimitive<TElement>;
+  /** Get the element primitive */
+  get element(): TElement;
+  /** Add a custom validation rule */
+  refine(fn: (value: ArrayState<TElement>) => boolean, message: string): ArrayPrimitive<TElement>;
+  /** Minimum array length */
+  minLength(length: number): ArrayPrimitive<TElement>;
+  /** Maximum array length */
+  maxLength(length: number): ArrayPrimitive<TElement>;
+  readonly _internal: PrimitiveInternal<ArrayState<TElement>, ArrayProxy<TElement>>;
+}
+/** Creates a new ArrayPrimitive with the given element type */
+declare const Array$1: <TElement extends AnyPrimitive>(element: TElement) => ArrayPrimitive<TElement>;
+//#endregion
+//#region src/primitives/Lazy.d.ts
+/**
+ * Type to infer state from a lazy thunk
+ */
+type InferLazyState<T extends () => AnyPrimitive> = InferState<ReturnType<T>>;
+/**
+ * Type to infer proxy from a lazy thunk
+ */
+type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType<T>>;
+/**
+ * Type to infer snapshot from a lazy thunk
+ */
+type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
+declare class LazyPrimitive<TThunk extends () => AnyPrimitive> implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>> {
+  readonly _tag: "LazyPrimitive";
+  readonly _State: InferLazyState<TThunk>;
+  readonly _Proxy: InferLazyProxy<TThunk>;
+  private readonly _thunk;
+  private _resolved;
+  constructor(thunk: TThunk);
+  /** Resolve and cache the lazy primitive */
+  private _resolve;
+  /** Mark this lazy primitive as required (delegates to resolved) */
+  required(): LazyPrimitive<TThunk>;
+  readonly _internal: PrimitiveInternal<InferLazyState<TThunk>, InferLazyProxy<TThunk>>;
+}
+/** Creates a new LazyPrimitive with the given thunk */
+declare const Lazy: <TThunk extends () => AnyPrimitive>(thunk: TThunk) => LazyPrimitive<TThunk>;
+//#endregion
+//#region src/primitives/Union.d.ts
+/**
+ * Type constraint for union variants - must be struct primitives
+ */
+type UnionVariants = Record<string, StructPrimitive<any, any>>;
+/**
+ * Infer the union state type from variants
+ */
+type InferUnionState<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferState<TVariants[K]> }[keyof TVariants];
+/**
+ * Infer the union snapshot type from variants
+ */
+type InferUnionSnapshot<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSnapshot<TVariants[K]> }[keyof TVariants];
+/**
+ * Proxy for accessing union variants
+ */
+interface UnionProxy<TVariants extends UnionVariants, TDiscriminator extends string, TDefined extends boolean = false> {
+  /** Gets the current union value */
+  get(): MaybeUndefined<InferUnionState<TVariants>, TDefined>;
+  /** Sets the entire union value */
+  set(value: InferUnionState<TVariants>): void;
+  /** Access a specific variant's proxy (assumes the variant is active) */
+  as<K$1 extends keyof TVariants>(variant: K$1): InferProxy<TVariants[K$1]>;
+  /** Pattern match on the variant type */
+  match<R>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K$1]>) => R }): R | undefined;
+  /** Returns a readonly snapshot of the union for rendering */
+  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
+}
+interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
+  readonly required: boolean;
+  readonly defaultValue: InferUnionState<TVariants> | undefined;
+  readonly discriminator: TDiscriminator;
+  readonly variants: TVariants;
+}
+declare class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TDefined extends boolean = false> implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>> {
+  readonly _tag: "UnionPrimitive";
+  readonly _State: InferUnionState<TVariants>;
+  readonly _Proxy: UnionProxy<TVariants, TDiscriminator, TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>);
+  /** Mark this union as required */
+  required(): UnionPrimitive<TVariants, TDiscriminator, true>;
+  /** Set a default value for this union */
+  default(defaultValue: InferUnionState<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true>;
+  /** Get the discriminator field name */
+  get discriminator(): TDiscriminator;
+  /** Get the variants */
+  get variants(): TVariants;
+  /** Find the variant key from a state value */
+  private _findVariantKey;
+  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>>;
+}
+/** Options for creating a Union primitive */
+interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {
+  /** The field name used to discriminate between variants (defaults to "type") */
+  readonly discriminator?: TDiscriminator;
+  /** The variant struct primitives */
+  readonly variants: TVariants;
+}
+/** Creates a new UnionPrimitive with the given variants */
+declare function Union<TVariants extends UnionVariants>(options: UnionOptions<TVariants, "type">): UnionPrimitive<TVariants, "type", false>;
+declare function Union<TVariants extends UnionVariants, TDiscriminator extends string>(options: UnionOptions<TVariants, TDiscriminator>): UnionPrimitive<TVariants, TDiscriminator, false>;
+//#endregion
+//#region src/primitives/Either.d.ts
+/**
+ * Scalar primitives that can be used as variants in Either
+ */
+type ScalarPrimitive = StringPrimitive<any> | NumberPrimitive<any> | BooleanPrimitive<any> | LiteralPrimitive<any, any>;
+/**
+ * Infer the union state type from a tuple of scalar primitives
+ */
+type InferEitherState<TVariants extends readonly ScalarPrimitive[]> = InferState<TVariants[number]>;
+/**
+ * Infer the union snapshot type from a tuple of scalar primitives
+ */
+type InferEitherSnapshot<TVariants extends readonly ScalarPrimitive[]> = InferState<TVariants[number]>;
+/**
+ * Match handlers for Either - optional handlers for each scalar type
+ */
+interface EitherMatchHandlers<R> {
+  string?: (value: string) => R;
+  number?: (value: number) => R;
+  boolean?: (value: boolean) => R;
+  literal?: (value: LiteralValue) => R;
+}
+/**
+ * Proxy for accessing Either values
+ */
+interface EitherProxy<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false> {
+  /** Gets the current value */
+  get(): MaybeUndefined<InferEitherState<TVariants>, TDefined>;
+  /** Sets the value to any of the allowed variant types */
+  set(value: InferEitherState<TVariants>): void;
+  /** Pattern match on the value type */
+  match<R>(handlers: EitherMatchHandlers<R>): R | undefined;
+  /** Returns a readonly snapshot of the value for rendering */
+  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TDefined>;
+}
+interface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {
+  readonly required: boolean;
+  readonly defaultValue: InferEitherState<TVariants> | undefined;
+  readonly variants: TVariants;
+}
+declare class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false> implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>> {
+  readonly _tag: "EitherPrimitive";
+  readonly _State: InferEitherState<TVariants>;
+  readonly _Proxy: EitherProxy<TVariants, TDefined>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: EitherPrimitiveSchema<TVariants>);
+  /** Mark this either as required */
+  required(): EitherPrimitive<TVariants, true>;
+  /** Set a default value for this either */
+  default(defaultValue: InferEitherState<TVariants>): EitherPrimitive<TVariants, true>;
+  /** Get the variants */
+  get variants(): TVariants;
+  /**
+   * Determine the type category of a value based on the variants
+   */
+  private _getValueType;
+  /**
+   * Find the matching variant for a value.
+   * For literals, matches exact value. For other types, matches by typeof.
+   */
+  private _findMatchingVariant;
+  /**
+   * Get the operation kind for a variant
+   */
+  private _getVariantOperationKind;
+  /**
+   * Validate a value against the matching variant, including running its validators.
+   * Throws ValidationError if the value doesn't match any variant or fails validation.
+   */
+  private _validateAndApplyToVariant;
+  readonly _internal: PrimitiveInternal<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>>;
+}
+/**
+ * Creates a new EitherPrimitive with the given scalar variant types.
+ * Validators defined on the variants are applied when validating values.
+ *
+ * @example
+ * ```typescript
+ * // String or number
+ * const value = Either(String(), Number());
+ *
+ * // String, number, or boolean
+ * const status = Either(String(), Number(), Boolean()).default("pending");
+ *
+ * // With literal types
+ * const mode = Either(Literal("auto"), Literal("manual"), Number());
+ *
+ * // With validators - validates string length and number range
+ * const constrained = Either(
+ *   String().min(2).max(50),
+ *   Number().max(255)
+ * );
+ * ```
+ */
+declare function Either<TVariants extends readonly ScalarPrimitive[]>(...variants: TVariants): EitherPrimitive<TVariants, false>;
+//#endregion
+//#region src/primitives/TreeNode.d.ts
+/**
+ * Any TreeNodePrimitive type - used for generic constraints.
+ */
+type AnyTreeNodePrimitive = TreeNodePrimitive<string, StructPrimitive<any>, readonly AnyTreeNodePrimitive[] | (() => readonly AnyTreeNodePrimitive[])>;
+/**
+ * Resolves children type - handles both array and lazy thunk
+ */
+type ResolveChildren<TChildren$1 extends readonly AnyTreeNodePrimitive[] | (() => readonly AnyTreeNodePrimitive[])> = TChildren$1 extends (() => readonly AnyTreeNodePrimitive[]) ? ReturnType<TChildren$1> : TChildren$1;
+/**
+ * Infer the data state type from a TreeNodePrimitive
+ */
+type InferTreeNodeDataState<T extends AnyTreeNodePrimitive> = T extends TreeNodePrimitive<any, infer TData, any> ? InferState<TData> : never;
+/**
+ * Infer the type literal from a TreeNodePrimitive
+ */
+type InferTreeNodeType<T extends AnyTreeNodePrimitive> = T extends TreeNodePrimitive<infer TType, any, any> ? TType : never;
+/**
+ * Infer the allowed children from a TreeNodePrimitive
+ */
+type InferTreeNodeChildren<T extends AnyTreeNodePrimitive> = T extends TreeNodePrimitive<any, any, infer TChildren> ? ResolveChildren<TChildren>[number] : never;
+/**
+ * Configuration for a TreeNode primitive
+ */
+interface TreeNodeConfig<TData$1 extends StructPrimitive<any>, TChildren$1 extends readonly AnyTreeNodePrimitive[] | (() => readonly AnyTreeNodePrimitive[])> {
+  readonly data: TData$1;
+  readonly children: TChildren$1;
+}
+/**
+ * TreeNodePrimitive - defines a node type with its data schema and allowed children
+ */
+declare class TreeNodePrimitive<TType extends string, TData$1 extends StructPrimitive<any>, TChildren$1 extends readonly AnyTreeNodePrimitive[] | (() => readonly AnyTreeNodePrimitive[])> {
+  readonly _tag: "TreeNodePrimitive";
+  readonly _Type: TType;
+  readonly _Data: TData$1;
+  readonly _Children: TChildren$1;
+  private readonly _type;
+  private readonly _data;
+  private readonly _children;
+  private _resolvedChildren;
+  constructor(type: TType, config: TreeNodeConfig<TData$1, TChildren$1>);
+  /** Get the node type identifier */
+  get type(): TType;
+  /** Get the data primitive */
+  get data(): TData$1;
+  /** Get resolved children (resolves lazy thunk if needed) */
+  get children(): ResolveChildren<TChildren$1>;
+  /** Check if a child type is allowed */
+  isChildAllowed(childType: string): boolean;
+}
+/** Creates a new TreeNodePrimitive with the given type and config */
+declare const TreeNode: <TType extends string, TData$1 extends StructPrimitive<any>, TChildren$1 extends readonly AnyTreeNodePrimitive[] | (() => readonly AnyTreeNodePrimitive[])>(type: TType, config: TreeNodeConfig<TData$1, TChildren$1>) => TreeNodePrimitive<TType, TData$1, TChildren$1>;
+//#endregion
+//#region src/primitives/Tree.d.ts
+/**
+ * A node in the tree state (flat storage format)
+ */
+interface TreeNodeState {
+  readonly id: string;
+  readonly type: string;
+  readonly parentId: string | null;
+  readonly pos: string;
+  readonly data: unknown;
+}
+/**
+ * Typed node state for a specific node type
+ */
+interface TypedTreeNodeState<TNode extends AnyTreeNodePrimitive> {
+  readonly id: string;
+  readonly type: InferTreeNodeType<TNode>;
+  readonly parentId: string | null;
+  readonly pos: string;
+  readonly data: InferTreeNodeDataState<TNode>;
+}
+/**
+ * The state type for trees - a flat array of nodes
+ */
+type TreeState<TRoot$1 extends AnyTreeNodePrimitive> = readonly TreeNodeState[];
+/**
+ * Snapshot of a single node for UI rendering (data properties spread at node level)
+ */
+type TreeNodeSnapshot<TNode extends AnyTreeNodePrimitive> = {
+  readonly id: string;
+  readonly type: InferTreeNodeType<TNode>;
+  readonly children: TreeNodeSnapshot<InferTreeNodeChildren<TNode>>[];
+} & InferTreeNodeDataState<TNode>;
+/**
+ * Infer the snapshot type for a tree (recursive tree structure for UI)
+ */
+type InferTreeSnapshot<T extends TreePrimitive<any>> = T extends TreePrimitive<infer TRoot> ? TreeNodeSnapshot<TRoot> : never;
+/**
+ * Typed proxy for a specific node type - provides type-safe data access
+ */
+interface TypedNodeProxy<TNode extends AnyTreeNodePrimitive> {
+  /** The node ID */
+  readonly id: string;
+  /** The node type */
+  readonly type: InferTreeNodeType<TNode>;
+  /** Access the node's data proxy */
+  readonly data: InferProxy<TNode["data"]>;
+  /** Get the raw node state */
+  get(): TypedTreeNodeState<TNode>;
+}
+/**
+ * Node proxy with type narrowing capabilities
+ */
+interface TreeNodeProxyBase<TRoot$1 extends AnyTreeNodePrimitive> {
+  /** The node ID */
+  readonly id: string;
+  /** The node type (string) */
+  readonly type: string;
+  /** Type guard - narrows the proxy to a specific node type */
+  is<TNode extends AnyTreeNodePrimitive>(nodeType: TNode): this is TypedNodeProxy<TNode>;
+  /** Type assertion - returns typed proxy (throws if wrong type) */
+  as<TNode extends AnyTreeNodePrimitive>(nodeType: TNode): TypedNodeProxy<TNode>;
+  /** Get the raw node state */
+  get(): TreeNodeState;
+}
+/**
+ * Proxy for accessing and modifying tree nodes
+ */
+interface TreeProxy<TRoot$1 extends AnyTreeNodePrimitive> {
+  /** Gets the entire tree state (flat array of nodes) */
+  get(): TreeState<TRoot$1>;
+  /** Replaces the entire tree */
+  set(nodes: TreeState<TRoot$1>): void;
+  /** Gets the root node state */
+  root(): TypedTreeNodeState<TRoot$1> | undefined;
+  /** Gets ordered children states of a parent (null for root's children) */
+  children(parentId: string | null): TreeNodeState[];
+  /** Gets a node proxy by ID with type narrowing capabilities */
+  node(id: string): TreeNodeProxyBase<TRoot$1> | undefined;
+  /** Insert a new node as the first child */
+  insertFirst<TNode extends AnyTreeNodePrimitive>(parentId: string | null, nodeType: TNode, data: InferTreeNodeDataState<TNode>): string;
+  /** Insert a new node as the last child */
+  insertLast<TNode extends AnyTreeNodePrimitive>(parentId: string | null, nodeType: TNode, data: InferTreeNodeDataState<TNode>): string;
+  /** Insert a new node at a specific index among siblings */
+  insertAt<TNode extends AnyTreeNodePrimitive>(parentId: string | null, index: number, nodeType: TNode, data: InferTreeNodeDataState<TNode>): string;
+  /** Insert a new node after a sibling */
+  insertAfter<TNode extends AnyTreeNodePrimitive>(siblingId: string, nodeType: TNode, data: InferTreeNodeDataState<TNode>): string;
+  /** Insert a new node before a sibling */
+  insertBefore<TNode extends AnyTreeNodePrimitive>(siblingId: string, nodeType: TNode, data: InferTreeNodeDataState<TNode>): string;
+  /** Remove a node and all its descendants */
+  remove(id: string): void;
+  /** Move a node to a new parent at a specific index */
+  move(nodeId: string, newParentId: string | null, toIndex: number): void;
+  /** Move a node after a sibling */
+  moveAfter(nodeId: string, siblingId: string): void;
+  /** Move a node before a sibling */
+  moveBefore(nodeId: string, siblingId: string): void;
+  /** Move a node to be the first child of a parent */
+  moveToFirst(nodeId: string, newParentId: string | null): void;
+  /** Move a node to be the last child of a parent */
+  moveToLast(nodeId: string, newParentId: string | null): void;
+  /** Returns a typed proxy for a specific node's data */
+  at<TNode extends AnyTreeNodePrimitive>(id: string, nodeType: TNode): InferProxy<TNode["data"]>;
+  /** Convert tree to a nested snapshot for UI rendering */
+  toSnapshot(): TreeNodeSnapshot<TRoot$1> | undefined;
+}
+interface TreePrimitiveSchema<TRoot$1 extends AnyTreeNodePrimitive> {
+  readonly required: boolean;
+  readonly defaultValue: TreeState<TRoot$1> | undefined;
+  readonly root: TRoot$1;
+  readonly validators: readonly Validator<TreeState<TRoot$1>>[];
+}
+declare class TreePrimitive<TRoot$1 extends AnyTreeNodePrimitive> implements Primitive<TreeState<TRoot$1>, TreeProxy<TRoot$1>> {
+  readonly _tag: "TreePrimitive";
+  readonly _State: TreeState<TRoot$1>;
+  readonly _Proxy: TreeProxy<TRoot$1>;
+  private readonly _schema;
+  private _nodeTypeRegistry;
+  private readonly _opDefinitions;
+  constructor(schema: TreePrimitiveSchema<TRoot$1>);
+  /** Mark this tree as required */
+  required(): TreePrimitive<TRoot$1>;
+  /** Set a default value for this tree */
+  default(defaultValue: TreeState<TRoot$1>): TreePrimitive<TRoot$1>;
+  /** Get the root node type */
+  get root(): TRoot$1;
+  /** Add a custom validation rule */
+  refine(fn: (value: TreeState<TRoot$1>) => boolean, message: string): TreePrimitive<TRoot$1>;
+  /**
+   * Build a registry of all node types reachable from root
+   */
+  private _buildNodeTypeRegistry;
+  /**
+   * Get a node type primitive by its type string
+   */
+  private _getNodeTypePrimitive;
+  /**
+   * Validate that a node type can be a child of a parent node type
+   */
+  private _validateChildType;
+  readonly _internal: PrimitiveInternal<TreeState<TRoot$1>, TreeProxy<TRoot$1>>;
+}
+/** Options for creating a Tree primitive */
+interface TreeOptions<TRoot$1 extends AnyTreeNodePrimitive> {
+  /** The root node type */
+  readonly root: TRoot$1;
+}
+/** Creates a new TreePrimitive with the given root node type */
+declare const Tree: <TRoot$1 extends AnyTreeNodePrimitive>(options: TreeOptions<TRoot$1>) => TreePrimitive<TRoot$1>;
+declare namespace Primitive_d_exports {
+  export { AnyPrimitive, AnyTreeNodePrimitive, Array$1 as Array, ArrayEntry, ArrayEntrySnapshot, ArrayPrimitive, ArrayProxy, ArraySnapshot, ArrayState, Boolean, BooleanPrimitive, BooleanProxy, Either, EitherMatchHandlers, EitherPrimitive, EitherProxy, InferEitherSnapshot, InferEitherState, InferLazyProxy, InferLazySnapshot, InferLazyState, InferProxy, InferSnapshot, InferState, InferStructSnapshot, InferStructState, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, InferTreeSnapshot, InferUnionSnapshot, InferUnionState, Lazy, LazyPrimitive, Literal, LiteralPrimitive, LiteralProxy, LiteralValue, MaybeUndefined, Number, NumberPrimitive, NumberProxy, Primitive, PrimitiveInternal, ResolveChildren, ScalarPrimitive, String, StringPrimitive, StringProxy, Struct, StructPrimitive, StructProxy, Tree, TreeNode, TreeNodeConfig, TreeNodePrimitive, TreeNodeProxyBase, TreeNodeSnapshot, TreeNodeState, TreeOptions, TreePrimitive, TreeProxy, TreeState, TypedNodeProxy, TypedTreeNodeState, Union, UnionOptions, UnionPrimitive, UnionProxy, UnionVariants, ValidationError, Validator, isCompatibleOperation, runValidators };
+}
+declare namespace Transaction_d_exports {
+  export { EncodedTransaction, Transaction, decode, empty, encode, isEmpty, make$2 as make, merge };
+}
+/**
+ * A Transaction represents a group of operations that were applied atomically.
+ */
+interface Transaction {
+  /** Unique identifier for this transaction */
+  readonly id: string;
+  /** Operations contained in this transaction */
+  readonly ops: ReadonlyArray<Operation<any, any, any>>;
+  /** Timestamp when the transaction was created */
+  readonly timestamp: number;
+}
+/**
+ * Creates a new Transaction with the given operations.
+ */
+declare const make$2: (ops: ReadonlyArray<Operation<any, any, any>>) => Transaction;
+/**
+ * Creates an empty Transaction.
+ */
+declare const empty: () => Transaction;
+/**
+ * Checks if a transaction is empty (has no operations).
+ */
+declare const isEmpty: (tx: Transaction) => boolean;
+/**
+ * Merges multiple transactions into one.
+ */
+declare const merge: (txs: ReadonlyArray<Transaction>) => Transaction;
+/**
+ * Encoded representation of a Transaction for network transport.
+ */
+interface EncodedTransaction {
+  readonly id: string;
+  readonly ops: ReadonlyArray<EncodedOperation>;
+  readonly timestamp: number;
+}
+/**
+ * Encodes a Transaction to a JSON-serializable format for network transport.
+ * @param transaction - The transaction to encode.
+ * @returns The encoded representation.
+ */
+declare const encode: (transaction: Transaction) => EncodedTransaction;
+/**
+ * Decodes an encoded transaction back to a Transaction.
+ * @param encoded - The encoded representation.
+ * @returns The decoded Transaction.
+ */
+declare const decode: (encoded: EncodedTransaction) => Transaction;
+declare namespace Document_d_exports {
+  export { Document, DocumentOptions, NestedTransactionError, OperationError, make$1 as make };
+}
+/**
+ * Error thrown when attempting to start a nested transaction.
+ */
+declare class NestedTransactionError extends Error {
+  readonly _tag = "NestedTransactionError";
+  constructor();
+}
+/**
+ * Error thrown when an operation fails to apply.
+ */
+declare class OperationError extends Error {
+  readonly _tag = "OperationError";
+  constructor(message: string);
+}
+/**
+ * A Document manages state for a primitive-based schema with transaction support.
+ */
+interface Document<TSchema extends AnyPrimitive> {
+  /** The schema defining this document's structure */
+  readonly schema: TSchema;
+  /** Root proxy for accessing and modifying document data */
+  readonly root: InferProxy<TSchema>;
+  /** Returns the current document state */
+  get(): InferState<TSchema> | undefined;
+  /**
+   * Returns a readonly snapshot of the entire document state for rendering.
+   * The snapshot is a type-safe, readonly structure where:
+   * - Required fields and fields with defaults are guaranteed to be defined
+   * - Optional fields may be undefined
+   */
+  toSnapshot(): InferSnapshot<TSchema>;
+  /**
+   * Runs a function within a transaction.
+   * All operations are collected and applied atomically.
+   * If the function throws, all changes are rolled back.
+   * @returns The return value of the function
+   */
+  transaction<R>(fn: (root: InferProxy<TSchema>) => R): R;
+  /**
+   * Applies external operations (e.g., from server/peers) to the document.
+   * These operations are NOT added to pending operations.
+   */
+  apply(ops: ReadonlyArray<Operation<any, any, any>>): void;
+  /**
+   * Returns pending local operations as a Transaction and clears the buffer.
+   */
+  flush(): Transaction;
+}
+interface DocumentOptions<TSchema extends AnyPrimitive> {
+  /** Initial state for the document */
+  readonly initial?: InferState<TSchema>;
+}
+/**
+ * Creates a new Document for the given schema.
+ */
+declare const make$1: <TSchema extends AnyPrimitive>(schema: TSchema, options?: DocumentOptions<TSchema>) => Document<TSchema>;
+declare namespace Presence_d_exports {
+  export { AnyPresence, Infer, Presence, PresenceEntry, PresenceOptions, isValid, make, validate, validateSafe };
+}
+/**
+ * A Presence schema wrapper that holds an Effect Schema for validation.
+ * This is used by both client and server to validate presence data.
+ */
+interface Presence<TData$1> {
+  readonly _tag: "Presence";
+  /** The Effect Schema used for validation */
+  readonly schema: Schema$1.Schema<TData$1>;
+  /** Branded type marker for inference */
+  readonly _Data: TData$1;
+}
+/**
+ * Options for creating a Presence instance.
+ */
+interface PresenceOptions<TData$1> {
+  /** The Effect Schema defining the presence data structure */
+  readonly schema: Schema$1.Schema<TData$1>;
+}
+/**
+ * Infer the data type from a Presence instance.
+ */
+type Infer<P extends Presence<any>> = P["_Data"];
+/**
+ * Any Presence type (for generic constraints).
+ */
+type AnyPresence = Presence<any>;
+/**
+ * A presence entry as stored/transmitted.
+ */
+interface PresenceEntry<TData$1 = unknown> {
+  /** The presence data */
+  readonly data: TData$1;
+  /** Optional user ID from authentication */
+  readonly userId?: string;
+}
+/**
+ * Creates a new Presence schema wrapper.
+ *
+ * @example
+ * ```typescript
+ * import { Presence } from "@voidhash/mimic";
+ * import { Schema } from "effect";
+ *
+ * const CursorPresence = Presence.make({
+ *   schema: Schema.Struct({
+ *     name: Schema.String,
+ *     cursor: Schema.Struct({
+ *       x: Schema.Number,
+ *       y: Schema.Number,
+ *     }),
+ *   }),
+ * });
+ * ```
+ */
+declare const make: <TData$1>(options: PresenceOptions<TData$1>) => Presence<TData$1>;
+/**
+ * Validates unknown data against a Presence schema.
+ * Throws a ParseError if validation fails.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to validate
+ * @returns The validated and typed data
+ * @throws ParseError if validation fails
+ */
+declare const validate: <TData$1>(presence: Presence<TData$1>, data: unknown) => TData$1;
+/**
+ * Safely validates unknown data against a Presence schema.
+ * Returns undefined if validation fails instead of throwing.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to validate
+ * @returns The validated data or undefined if invalid
+ */
+declare const validateSafe: <TData$1>(presence: Presence<TData$1>, data: unknown) => TData$1 | undefined;
+/**
+ * Checks if unknown data is valid according to a Presence schema.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to check
+ * @returns true if valid, false otherwise
+ */
+declare const isValid: <TData$1>(presence: Presence<TData$1>, data: unknown) => data is TData$1;
+//#endregion
+export { Document_d_exports as Document, Operation_d_exports as Operation, OperationPath_d_exports as OperationPath, Presence_d_exports as Presence, Primitive_d_exports as Primitive, ProxyEnvironment_d_exports as ProxyEnvironment, Transaction_d_exports as Transaction, Transform_d_exports as Transform };
+//# sourceMappingURL=index.d.mts.map