@voidhash/mimic 0.0.1-alpha.7 → 0.0.1-alpha.8

package/dist/client/index.d.cts

@@ -0,0 +1,692 @@
+import { a as InferState, f as Operation, h as __export, l as EncodedTransaction, n as AnyPrimitive, o as TransformResult$1, r as InferProxy, u as Transaction } from "../Primitive-BK7kfHJZ.cjs";
+import { i as Presence_d_exports, n as Infer, r as PresenceEntry$1, t as AnyPresence } from "../Presence-DKKP4v5X.cjs";
+
+//#region src/client/Transport.d.ts
+declare namespace Transport_d_exports {
+  export { AuthMessage, AuthResultMessage, ClientMessage, EncodedClientMessage, EncodedServerMessage, EncodedSubmitTransactionMessage, EncodedTransactionMessage, ErrorMessage, PingMessage, PongMessage, PresenceClearMessage, PresenceEntry, PresenceRemoveMessage, PresenceSetMessage, PresenceSnapshotMessage, PresenceUpdateMessage, RequestSnapshotMessage, ServerMessage, SnapshotMessage, SubmitTransactionMessage, TransactionMessage, Transport, TransportEvent, TransportEventHandler, TransportOptions };
+}
+/**
+ * Message received when the server broadcasts a committed transaction.
+ */
+interface TransactionMessage {
+  readonly type: "transaction";
+  readonly transaction: Transaction;
+  /** Server-assigned version number for ordering */
+  readonly version: number;
+}
+/**
+ * Message received when requesting or receiving a full state snapshot.
+ */
+interface SnapshotMessage {
+  readonly type: "snapshot";
+  readonly state: unknown;
+  readonly version: number;
+}
+/**
+ * Message received when the server rejects a transaction.
+ */
+interface ErrorMessage {
+  readonly type: "error";
+  readonly transactionId: string;
+  readonly reason: string;
+}
+/**
+ * Message received in response to a ping (heartbeat).
+ */
+interface PongMessage {
+  readonly type: "pong";
+}
+/**
+ * Message received after authentication attempt.
+ */
+interface AuthResultMessage {
+  readonly type: "auth_result";
+  readonly success: boolean;
+  readonly error?: string;
+}
+/**
+ * A presence entry as transmitted.
+ */
+interface PresenceEntry {
+  /** The presence data */
+  readonly data: unknown;
+  /** Optional user ID from authentication */
+  readonly userId?: string;
+}
+/**
+ * Message received with initial presence state after authentication.
+ */
+interface PresenceSnapshotMessage {
+  readonly type: "presence_snapshot";
+  /** This connection's ID (used to identify self) */
+  readonly selfId: string;
+  /** Map of connectionId to presence entry */
+  readonly presences: Record<string, PresenceEntry>;
+}
+/**
+ * Message received when another user updates their presence.
+ */
+interface PresenceUpdateMessage {
+  readonly type: "presence_update";
+  /** The connection ID of the user who updated */
+  readonly id: string;
+  /** The presence data */
+  readonly data: unknown;
+  /** Optional user ID from authentication */
+  readonly userId?: string;
+}
+/**
+ * Message received when another user's presence is removed (disconnect).
+ */
+interface PresenceRemoveMessage {
+  readonly type: "presence_remove";
+  /** The connection ID of the user who disconnected */
+  readonly id: string;
+}
+/**
+ * Union of all possible server messages.
+ */
+type ServerMessage = TransactionMessage | SnapshotMessage | ErrorMessage | PongMessage | AuthResultMessage | PresenceSnapshotMessage | PresenceUpdateMessage | PresenceRemoveMessage;
+/**
+ * Message sent to submit a transaction to the server.
+ */
+interface SubmitTransactionMessage {
+  readonly type: "submit";
+  readonly transaction: Transaction;
+}
+/**
+ * Message sent to request a full state snapshot.
+ */
+interface RequestSnapshotMessage {
+  readonly type: "request_snapshot";
+}
+/**
+ * Message sent as heartbeat ping.
+ */
+interface PingMessage {
+  readonly type: "ping";
+}
+/**
+ * Message sent to authenticate with the server.
+ */
+interface AuthMessage {
+  readonly type: "auth";
+  readonly token: string;
+}
+/**
+ * Message sent to set/update this client's presence.
+ */
+interface PresenceSetMessage {
+  readonly type: "presence_set";
+  /** The presence data (validated against schema on client before sending) */
+  readonly data: unknown;
+}
+/**
+ * Message sent to clear this client's presence.
+ */
+interface PresenceClearMessage {
+  readonly type: "presence_clear";
+}
+/**
+ * Union of all possible client messages.
+ */
+type ClientMessage = SubmitTransactionMessage | RequestSnapshotMessage | PingMessage | AuthMessage | PresenceSetMessage | PresenceClearMessage;
+/**
+ * Encoded transaction message for network transport.
+ */
+interface EncodedTransactionMessage {
+  readonly type: "transaction";
+  readonly transaction: EncodedTransaction;
+  readonly version: number;
+}
+/**
+ * Encoded submit message for network transport.
+ */
+interface EncodedSubmitTransactionMessage {
+  readonly type: "submit";
+  readonly transaction: EncodedTransaction;
+}
+/**
+ * Union of all possible encoded server messages (for network transport).
+ */
+type EncodedServerMessage = EncodedTransactionMessage | SnapshotMessage | ErrorMessage | PongMessage | AuthResultMessage | PresenceSnapshotMessage | PresenceUpdateMessage | PresenceRemoveMessage;
+/**
+ * Union of all possible encoded client messages (for network transport).
+ */
+type EncodedClientMessage = EncodedSubmitTransactionMessage | RequestSnapshotMessage | PingMessage | AuthMessage | PresenceSetMessage | PresenceClearMessage;
+/**
+ * Abstract transport interface for server communication.
+ * Implementations can use WebSocket, HTTP, or any other protocol.
+ */
+interface Transport {
+  /**
+   * Sends a transaction to the server for processing.
+   * @param transaction - The transaction to submit
+   */
+  readonly send: (transaction: Transaction) => void;
+  /**
+   * Requests a full state snapshot from the server.
+   * Used for initial sync or recovery from drift.
+   */
+  readonly requestSnapshot: () => void;
+  /**
+   * Subscribes to messages from the server.
+   * @param handler - Callback invoked for each server message
+   * @returns Unsubscribe function
+   */
+  readonly subscribe: (handler: (message: ServerMessage) => void) => () => void;
+  /**
+   * Establishes connection to the server.
+   * @returns Promise that resolves when connected
+   */
+  readonly connect: () => Promise<void>;
+  /**
+   * Disconnects from the server.
+   */
+  readonly disconnect: () => void;
+  /**
+   * Returns whether the transport is currently connected.
+   */
+  readonly isConnected: () => boolean;
+  /**
+   * Sends presence data to the server.
+   * The data should be validated against the presence schema before calling.
+   * @param data - The presence data to set
+   */
+  readonly sendPresenceSet: (data: unknown) => void;
+  /**
+   * Clears this client's presence on the server.
+   */
+  readonly sendPresenceClear: () => void;
+}
+/**
+ * Events emitted by the transport for connection status.
+ */
+type TransportEvent = {
+  type: "connected";
+} | {
+  type: "disconnected";
+  reason?: string;
+} | {
+  type: "reconnecting";
+  attempt: number;
+} | {
+  type: "error";
+  error: Error;
+};
+/**
+ * Handler for transport events.
+ */
+type TransportEventHandler = (event: TransportEvent) => void;
+/**
+ * Options for creating a transport.
+ */
+interface TransportOptions {
+  /** Handler for transport lifecycle events */
+  readonly onEvent?: TransportEventHandler;
+  /** Timeout in milliseconds for connection attempts */
+  readonly connectionTimeout?: number;
+  /** Whether to automatically reconnect on disconnect */
+  readonly autoReconnect?: boolean;
+  /** Maximum number of reconnection attempts */
+  readonly maxReconnectAttempts?: number;
+  /** Base delay between reconnection attempts (ms) */
+  readonly reconnectDelay?: number;
+}
+declare namespace ClientDocument_d_exports {
+  export { ClientDocument, ClientDocumentListener, ClientDocumentOptions, ClientPresence, PresenceListener, make$2 as make };
+}
+/**
+ * Listener for presence changes.
+ */
+interface PresenceListener<_TData> {
+  /** Called when any presence changes (self or others) */
+  readonly onPresenceChange?: () => void;
+}
+/**
+ * Presence API exposed on the ClientDocument.
+ */
+interface ClientPresence<TData> {
+  /**
+   * Returns this client's connection ID (set after receiving presence_snapshot).
+   * Returns undefined before the snapshot is received.
+   */
+  readonly selfId: () => string | undefined;
+  /**
+   * Returns this client's current presence data.
+   * Returns undefined if not set.
+   */
+  readonly self: () => TData | undefined;
+  /**
+   * Returns a map of other clients' presence data.
+   * Keys are connection IDs.
+   */
+  readonly others: () => ReadonlyMap<string, PresenceEntry$1<TData>>;
+  /**
+   * Returns all presence entries including self.
+   */
+  readonly all: () => ReadonlyMap<string, PresenceEntry$1<TData>>;
+  /**
+   * Sets this client's presence data.
+   * Validates against the presence schema before sending.
+   * @throws ParseError if validation fails
+   */
+  readonly set: (data: TData) => void;
+  /**
+   * Clears this client's presence data.
+   */
+  readonly clear: () => void;
+  /**
+   * Subscribes to presence changes.
+   * @returns Unsubscribe function
+   */
+  readonly subscribe: (listener: PresenceListener<TData>) => () => void;
+}
+/**
+ * Options for creating a ClientDocument.
+ */
+interface ClientDocumentOptions<TSchema extends AnyPrimitive, TPresence extends AnyPresence | undefined = undefined> {
+  /** The schema defining the document structure */
+  readonly schema: TSchema;
+  /** Transport for server communication */
+  readonly transport: Transport;
+  /** Initial state (optional, will sync from server if not provided) */
+  readonly initialState?: InferState<TSchema>;
+  /** Initial server version (optional) */
+  readonly initialVersion?: number;
+  /** Called when server rejects a transaction */
+  readonly onRejection?: (transaction: Transaction, reason: string) => void;
+  /** Called when optimistic state changes */
+  readonly onStateChange?: (state: InferState<TSchema> | undefined) => void;
+  /** Called when connection status changes */
+  readonly onConnectionChange?: (connected: boolean) => void;
+  /** Called when client is fully initialized and ready */
+  readonly onReady?: () => void;
+  /** Timeout in ms for pending transactions (default: 30000) */
+  readonly transactionTimeout?: number;
+  /** Timeout in ms for initialization (default: 10000) */
+  readonly initTimeout?: number;
+  /** Enable debug logging for all activity (default: false) */
+  readonly debug?: boolean;
+  /**
+   * Optional presence schema for ephemeral per-user data.
+   * When provided, enables the presence API on the ClientDocument.
+   */
+  readonly presence?: TPresence;
+  /** Initial presence data, that will be set on the ClientDocument when it is created */
+  readonly initialPresence?: TPresence extends AnyPresence ? Infer<TPresence> : undefined;
+}
+/**
+ * Listener callbacks for subscribing to ClientDocument events.
+ */
+interface ClientDocumentListener<TSchema extends AnyPrimitive> {
+  /** Called when optimistic state changes */
+  readonly onStateChange?: (state: InferState<TSchema> | undefined) => void;
+  /** Called when connection status changes */
+  readonly onConnectionChange?: (connected: boolean) => void;
+  /** Called when client is fully initialized and ready */
+  readonly onReady?: () => void;
+}
+/**
+ * A ClientDocument provides optimistic updates with server synchronization.
+ */
+interface ClientDocument<TSchema extends AnyPrimitive, TPresence extends AnyPresence | undefined = undefined> {
+  /** The schema defining this document's structure */
+  readonly schema: TSchema;
+  /** Root proxy for accessing and modifying document data (optimistic) */
+  readonly root: InferProxy<TSchema>;
+  /** Returns the current optimistic state (server + pending) */
+  get(): InferState<TSchema> | undefined;
+  /** Returns the confirmed server state */
+  getServerState(): InferState<TSchema> | undefined;
+  /** Returns the current server version */
+  getServerVersion(): number;
+  /** Returns pending transactions count */
+  getPendingCount(): number;
+  /** Returns whether there are pending transactions */
+  hasPendingChanges(): boolean;
+  /**
+   * Runs a function within a transaction.
+   * Changes are applied optimistically and sent to the server.
+   */
+  transaction<R>(fn: (root: InferProxy<TSchema>) => R): R;
+  /**
+   * Connects to the server and starts syncing.
+   */
+  connect(): Promise<void>;
+  /**
+   * Disconnects from the server.
+   */
+  disconnect(): void;
+  /**
+   * Returns whether currently connected to the server.
+   */
+  isConnected(): boolean;
+  /**
+   * Forces a full resync from the server.
+   */
+  resync(): void;
+  /**
+   * Returns whether the client is fully initialized and ready.
+   */
+  isReady(): boolean;
+  /**
+   * Subscribes to document events (state changes, connection changes, ready).
+   * @returns Unsubscribe function
+   */
+  subscribe(listener: ClientDocumentListener<TSchema>): () => void;
+  /**
+   * Presence API for ephemeral per-user data.
+   * Only available when presence schema is provided in options.
+   */
+  readonly presence: TPresence extends AnyPresence ? ClientPresence<Infer<TPresence>> : undefined;
+}
+/**
+ * Creates a new ClientDocument for the given schema.
+ */
+declare const make$2: <TSchema extends AnyPrimitive, TPresence extends AnyPresence | undefined = undefined>(options: ClientDocumentOptions<TSchema, TPresence>) => ClientDocument<TSchema, TPresence>;
+declare namespace WebSocketTransport_d_exports {
+  export { WebSocketTransportOptions, make$1 as make };
+}
+/**
+ * Options for creating a WebSocket transport.
+ */
+interface WebSocketTransportOptions extends TransportOptions {
+  /** WebSocket URL (ws:// or wss://) - base URL without document path */
+  readonly url: string;
+  /** Document ID to connect to. Will be appended to URL as /doc/{documentId} */
+  readonly documentId?: string;
+  /** WebSocket subprotocols */
+  readonly protocols?: string[];
+  /** Authentication token or function that returns a token */
+  readonly authToken?: string | (() => string | Promise<string>);
+  /** Interval between heartbeat pings (ms). Default: 30000 */
+  readonly heartbeatInterval?: number;
+  /** Timeout to wait for pong response (ms). Default: 10000 */
+  readonly heartbeatTimeout?: number;
+  /** Maximum delay between reconnection attempts (ms). Default: 30000 */
+  readonly maxReconnectDelay?: number;
+}
+declare const make$1: (options: WebSocketTransportOptions) => Transport;
+declare namespace Rebase_d_exports {
+  export { TransformResult, rebaseAfterRejection, rebaseAfterRejectionWithPrimitive, rebasePendingTransactions, rebasePendingTransactionsWithPrimitive, transformOperation, transformOperationWithPrimitive, transformTransaction, transformTransactionWithPrimitive };
+}
+type TransformResult = TransformResult$1;
+/**
+ * Transforms a client operation against a server operation using a primitive.
+ *
+ * This delegates to the primitive's transformOperation method, which handles
+ * type-specific conflict resolution.
+ *
+ * @param clientOp - The client's operation to transform
+ * @param serverOp - The server's operation that has already been applied
+ * @param primitive - The root primitive to use for transformation
+ * @returns TransformResult indicating how the client operation should be handled
+ */
+declare const transformOperationWithPrimitive: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>, primitive: AnyPrimitive) => TransformResult;
+/**
+ * Transforms a client operation against a server operation.
+ *
+ * This is a standalone implementation for cases where the primitive is not available.
+ * For schema-aware transformation, use transformOperationWithPrimitive instead.
+ *
+ * The key principle: client ops "shadow" server ops for the same path,
+ * meaning if both touch the same field, the client's intention wins
+ * (since it was made with knowledge of the server state at that time).
+ */
+declare const transformOperation: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>) => TransformResult;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * Uses the primitive's transformOperation for schema-aware transformation.
+ */
+declare const transformTransactionWithPrimitive: (clientTx: Transaction, serverTx: Transaction, primitive: AnyPrimitive) => Transaction;
+/**
+ * Transforms all operations in a client transaction against a server transaction.
+ * This is a standalone version that doesn't require a primitive.
+ */
+declare const transformTransaction: (clientTx: Transaction, serverTx: Transaction) => Transaction;
+/**
+ * Rebases a list of pending transactions against a server transaction using a primitive.
+ *
+ * This is called when a server transaction arrives that is NOT one of our pending
+ * transactions. We need to transform all pending transactions to work correctly
+ * on top of the new server state.
+ */
+declare const rebasePendingTransactionsWithPrimitive: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction, primitive: AnyPrimitive) => Transaction[];
+/**
+ * Rebases a list of pending transactions against a server transaction.
+ *
+ * This is called when a server transaction arrives that is NOT one of our pending
+ * transactions. We need to transform all pending transactions to work correctly
+ * on top of the new server state.
+ */
+declare const rebasePendingTransactions: (pendingTxs: ReadonlyArray<Transaction>, serverTx: Transaction) => Transaction[];
+/**
+ * Rebases pending transactions after a rejection using a primitive.
+ *
+ * When a transaction is rejected, we need to re-transform remaining pending
+ * transactions as if the rejected transaction never happened. This is done by
+ * rebuilding from the original operations against the current server state.
+ *
+ * @param originalPendingTxs - The original pending transactions before any rebasing
+ * @param rejectedTxId - ID of the rejected transaction
+ * @param serverTxsSinceOriginal - Server transactions that have arrived since original
+ * @param primitive - The root primitive to use for transformation
+ */
+declare const rebaseAfterRejectionWithPrimitive: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>, primitive: AnyPrimitive) => Transaction[];
+/**
+ * Rebases pending transactions after a rejection.
+ *
+ * When a transaction is rejected, we need to re-transform remaining pending
+ * transactions as if the rejected transaction never happened. This is done by
+ * rebuilding from the original operations against the current server state.
+ *
+ * @param originalPendingTxs - The original pending transactions before any rebasing
+ * @param rejectedTxId - ID of the rejected transaction
+ * @param serverTxsSinceOriginal - Server transactions that have arrived since original
+ */
+declare const rebaseAfterRejection: (originalPendingTxs: ReadonlyArray<Transaction>, rejectedTxId: string, serverTxsSinceOriginal: ReadonlyArray<Transaction>) => Transaction[];
+declare namespace StateMonitor_d_exports {
+  export { PendingInfo, RecoveryAction, StateMonitor, StateMonitorEvent, StateMonitorEventHandler, StateMonitorOptions, StateMonitorStatus, determineRecoveryAction, make };
+}
+/**
+ * Events emitted by the state monitor.
+ */
+type StateMonitorEvent = {
+  type: "drift_detected";
+  expectedVersion: number;
+  receivedVersion: number;
+} | {
+  type: "recovery_started";
+} | {
+  type: "recovery_completed";
+  version: number;
+} | {
+  type: "recovery_failed";
+  error: Error;
+} | {
+  type: "pending_timeout";
+  transactionId: string;
+  elapsedMs: number;
+} | {
+  type: "health_check";
+  pendingCount: number;
+  oldestPendingMs: number | null;
+};
+/**
+ * Handler for state monitor events.
+ */
+type StateMonitorEventHandler = (event: StateMonitorEvent) => void;
+/**
+ * Options for creating a StateMonitor.
+ */
+interface StateMonitorOptions {
+  /** Handler for monitor events */
+  readonly onEvent?: StateMonitorEventHandler;
+  /** Interval for health checks in ms (default: 5000) */
+  readonly healthCheckInterval?: number;
+  /** Threshold for considering a pending transaction "stale" in ms (default: 10000) */
+  readonly stalePendingThreshold?: number;
+  /** Maximum allowed version gap before triggering recovery (default: 10) */
+  readonly maxVersionGap?: number;
+}
+/**
+ * Pending transaction info for monitoring.
+ */
+interface PendingInfo {
+  readonly id: string;
+  readonly sentAt: number;
+}
+/**
+ * A StateMonitor watches for state drift and triggers recovery.
+ */
+interface StateMonitor {
+  /**
+   * Called when a server transaction is received.
+   * Returns true if the version is valid, false if drift is detected.
+   */
+  readonly onServerVersion: (version: number) => boolean;
+  /**
+   * Called when a pending transaction is added.
+   */
+  readonly trackPending: (info: PendingInfo) => void;
+  /**
+   * Called when a pending transaction is confirmed or rejected.
+   */
+  readonly untrackPending: (id: string) => void;
+  /**
+   * Returns pending transactions that have exceeded the stale threshold.
+   */
+  readonly getStalePending: () => PendingInfo[];
+  /**
+   * Returns current monitoring status.
+   */
+  readonly getStatus: () => StateMonitorStatus;
+  /**
+   * Starts the health check loop.
+   */
+  readonly start: () => void;
+  /**
+   * Stops the health check loop.
+   */
+  readonly stop: () => void;
+  /**
+   * Resets the monitor state (called after recovery).
+   */
+  readonly reset: (newVersion: number) => void;
+}
+/**
+ * Current monitoring status.
+ */
+interface StateMonitorStatus {
+  readonly expectedVersion: number;
+  readonly pendingCount: number;
+  readonly oldestPendingMs: number | null;
+  readonly isHealthy: boolean;
+  readonly isRecovering: boolean;
+}
+/**
+ * Creates a new StateMonitor.
+ */
+declare const make: (options?: StateMonitorOptions) => StateMonitor;
+/**
+ * Recovery actions that can be taken.
+ */
+type RecoveryAction = {
+  type: "request_snapshot";
+} | {
+  type: "retry_pending";
+  transactionIds: string[];
+} | {
+  type: "drop_pending";
+  transactionIds: string[];
+};
+/**
+ * Determines the appropriate recovery action based on current state.
+ */
+declare const determineRecoveryAction: (status: StateMonitorStatus, stalePending: PendingInfo[]) => RecoveryAction;
+//#endregion
+//#region src/client/errors.d.ts
+/**
+ * Base error class for all mimic-client errors.
+ */
+declare class MimicClientError extends Error {
+  readonly _tag: string;
+  constructor(message: string);
+}
+/**
+ * Error thrown when a transaction is rejected by the server.
+ */
+declare class TransactionRejectedError extends MimicClientError {
+  readonly _tag = "TransactionRejectedError";
+  readonly transaction: Transaction;
+  readonly reason: string;
+  constructor(transaction: Transaction, reason: string);
+}
+/**
+ * Error thrown when the transport is not connected.
+ */
+declare class NotConnectedError extends MimicClientError {
+  readonly _tag = "NotConnectedError";
+  constructor();
+}
+/**
+ * Error thrown when connection to the server fails.
+ */
+declare class ConnectionError extends MimicClientError {
+  readonly _tag = "ConnectionError";
+  readonly cause?: Error;
+  constructor(message: string, cause?: Error);
+}
+/**
+ * Error thrown when state drift is detected and cannot be recovered.
+ */
+declare class StateDriftError extends MimicClientError {
+  readonly _tag = "StateDriftError";
+  readonly expectedVersion: number;
+  readonly receivedVersion: number;
+  constructor(expectedVersion: number, receivedVersion: number);
+}
+/**
+ * Error thrown when a pending transaction times out waiting for confirmation.
+ */
+declare class TransactionTimeoutError extends MimicClientError {
+  readonly _tag = "TransactionTimeoutError";
+  readonly transaction: Transaction;
+  readonly timeoutMs: number;
+  constructor(transaction: Transaction, timeoutMs: number);
+}
+/**
+ * Error thrown when rebasing operations fails.
+ */
+declare class RebaseError extends MimicClientError {
+  readonly _tag = "RebaseError";
+  readonly transactionId: string;
+  constructor(transactionId: string, message: string);
+}
+/**
+ * Error thrown when the client document is in an invalid state.
+ */
+declare class InvalidStateError extends MimicClientError {
+  readonly _tag = "InvalidStateError";
+  constructor(message: string);
+}
+/**
+ * Error thrown when WebSocket connection or communication fails.
+ */
+declare class WebSocketError extends MimicClientError {
+  readonly _tag = "WebSocketError";
+  readonly code?: number;
+  readonly reason?: string;
+  constructor(message: string, code?: number, reason?: string);
+}
+/**
+ * Error thrown when authentication fails.
+ */
+declare class AuthenticationError extends MimicClientError {
+  readonly _tag = "AuthenticationError";
+  constructor(message: string);
+}
+//#endregion
+export { AuthenticationError, ClientDocument_d_exports as ClientDocument, ConnectionError, InvalidStateError, MimicClientError, NotConnectedError, Presence_d_exports as Presence, Rebase_d_exports as Rebase, RebaseError, StateDriftError, StateMonitor_d_exports as StateMonitor, TransactionRejectedError, TransactionTimeoutError, Transport_d_exports as Transport, WebSocketError, WebSocketTransport_d_exports as WebSocketTransport };
+//# sourceMappingURL=index.d.cts.map