@objectstack/spec 0.6.1 → 0.7.2

package/dist/system/collaboration.zod.d.ts

@@ -0,0 +1,2099 @@
+import { z } from 'zod';
+/**
+ * Real-Time Collaboration Protocol
+ *
+ * Defines schemas for real-time collaborative editing in ObjectStack.
+ * Supports Operational Transformation (OT), CRDT (Conflict-free Replicated Data Types),
+ * cursor sharing, and awareness state for collaborative applications.
+ *
+ * Industry alignment: Google Docs, Figma, VSCode Live Share, Yjs
+ */
+/**
+ * OT Operation Type Enum
+ * Types of operations in Operational Transformation
+ */
+export declare const OTOperationType: z.ZodEnum<["insert", "delete", "retain"]>;
+export type OTOperationType = z.infer<typeof OTOperationType>;
+/**
+ * OT Operation Component
+ * Single component of an OT operation
+ */
+export declare const OTComponentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"insert">;
+    text: z.ZodString;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    type: "insert";
+    text: string;
+    attributes?: Record<string, any> | undefined;
+}, {
+    type: "insert";
+    text: string;
+    attributes?: Record<string, any> | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"delete">;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "delete";
+    count: number;
+}, {
+    type: "delete";
+    count: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"retain">;
+    count: z.ZodNumber;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    type: "retain";
+    count: number;
+    attributes?: Record<string, any> | undefined;
+}, {
+    type: "retain";
+    count: number;
+    attributes?: Record<string, any> | undefined;
+}>]>;
+export type OTComponent = z.infer<typeof OTComponentSchema>;
+/**
+ * OT Operation Schema
+ * Represents a complete OT operation
+ * Based on the OT algorithm used by Google Docs and other collaborative editors
+ */
+export declare const OTOperationSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    documentId: z.ZodString;
+    userId: z.ZodString;
+    sessionId: z.ZodString;
+    components: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"insert">;
+        text: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "insert";
+        text: string;
+        attributes?: Record<string, any> | undefined;
+    }, {
+        type: "insert";
+        text: string;
+        attributes?: Record<string, any> | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"delete">;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "delete";
+        count: number;
+    }, {
+        type: "delete";
+        count: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"retain">;
+        count: z.ZodNumber;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "retain";
+        count: number;
+        attributes?: Record<string, any> | undefined;
+    }, {
+        type: "retain";
+        count: number;
+        attributes?: Record<string, any> | undefined;
+    }>]>, "many">;
+    baseVersion: z.ZodNumber;
+    timestamp: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    components: ({
+        type: "insert";
+        text: string;
+        attributes?: Record<string, any> | undefined;
+    } | {
+        type: "delete";
+        count: number;
+    } | {
+        type: "retain";
+        count: number;
+        attributes?: Record<string, any> | undefined;
+    })[];
+    timestamp: string;
+    operationId: string;
+    documentId: string;
+    sessionId: string;
+    baseVersion: number;
+    metadata?: Record<string, any> | undefined;
+}, {
+    userId: string;
+    components: ({
+        type: "insert";
+        text: string;
+        attributes?: Record<string, any> | undefined;
+    } | {
+        type: "delete";
+        count: number;
+    } | {
+        type: "retain";
+        count: number;
+        attributes?: Record<string, any> | undefined;
+    })[];
+    timestamp: string;
+    operationId: string;
+    documentId: string;
+    sessionId: string;
+    baseVersion: number;
+    metadata?: Record<string, any> | undefined;
+}>;
+export type OTOperation = z.infer<typeof OTOperationSchema>;
+/**
+ * OT Transform Result
+ * Result of transforming one operation against another
+ */
+export declare const OTTransformResultSchema: z.ZodObject<{
+    operation: z.ZodObject<{
+        operationId: z.ZodString;
+        documentId: z.ZodString;
+        userId: z.ZodString;
+        sessionId: z.ZodString;
+        components: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"insert">;
+            text: z.ZodString;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        }, {
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"delete">;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: "delete";
+            count: number;
+        }, {
+            type: "delete";
+            count: number;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"retain">;
+            count: z.ZodNumber;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        }, {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        }>]>, "many">;
+        baseVersion: z.ZodNumber;
+        timestamp: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    }>;
+    transformed: z.ZodBoolean;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    operation: {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    };
+    transformed: boolean;
+    conflicts?: string[] | undefined;
+}, {
+    operation: {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    };
+    transformed: boolean;
+    conflicts?: string[] | undefined;
+}>;
+export type OTTransformResult = z.infer<typeof OTTransformResultSchema>;
+/**
+ * CRDT Type Enum
+ * Types of CRDTs supported
+ */
+export declare const CRDTType: z.ZodEnum<["lww-register", "g-counter", "pn-counter", "g-set", "or-set", "lww-map", "text", "tree", "json"]>;
+export type CRDTType = z.infer<typeof CRDTType>;
+/**
+ * Vector Clock Schema
+ * Tracks causality in distributed systems
+ */
+export declare const VectorClockSchema: z.ZodObject<{
+    clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    clock: Record<string, number>;
+}, {
+    clock: Record<string, number>;
+}>;
+export type VectorClock = z.infer<typeof VectorClockSchema>;
+/**
+ * LWW-Register Schema
+ * Last-Write-Wins Register CRDT
+ */
+export declare const LWWRegisterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lww-register">;
+    value: z.ZodAny;
+    timestamp: z.ZodString;
+    replicaId: z.ZodString;
+    vectorClock: z.ZodOptional<z.ZodObject<{
+        clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        clock: Record<string, number>;
+    }, {
+        clock: Record<string, number>;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "lww-register";
+    timestamp: string;
+    replicaId: string;
+    value?: any;
+    vectorClock?: {
+        clock: Record<string, number>;
+    } | undefined;
+}, {
+    type: "lww-register";
+    timestamp: string;
+    replicaId: string;
+    value?: any;
+    vectorClock?: {
+        clock: Record<string, number>;
+    } | undefined;
+}>;
+export type LWWRegister = z.infer<typeof LWWRegisterSchema>;
+/**
+ * Counter Operation Schema
+ * Operations for Counter CRDTs
+ */
+export declare const CounterOperationSchema: z.ZodObject<{
+    replicaId: z.ZodString;
+    delta: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    delta: number;
+    timestamp: string;
+    replicaId: string;
+}, {
+    delta: number;
+    timestamp: string;
+    replicaId: string;
+}>;
+export type CounterOperation = z.infer<typeof CounterOperationSchema>;
+/**
+ * G-Counter Schema
+ * Grow-only Counter CRDT
+ */
+export declare const GCounterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"g-counter">;
+    counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "g-counter";
+    counts: Record<string, number>;
+}, {
+    type: "g-counter";
+    counts: Record<string, number>;
+}>;
+export type GCounter = z.infer<typeof GCounterSchema>;
+/**
+ * PN-Counter Schema
+ * Positive-Negative Counter CRDT (supports increment and decrement)
+ */
+export declare const PNCounterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pn-counter">;
+    positive: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    negative: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "pn-counter";
+    positive: Record<string, number>;
+    negative: Record<string, number>;
+}, {
+    type: "pn-counter";
+    positive: Record<string, number>;
+    negative: Record<string, number>;
+}>;
+export type PNCounter = z.infer<typeof PNCounterSchema>;
+/**
+ * OR-Set Element Schema
+ * Element in an Observed-Remove Set
+ */
+export declare const ORSetElementSchema: z.ZodObject<{
+    value: z.ZodAny;
+    timestamp: z.ZodString;
+    replicaId: z.ZodString;
+    uid: z.ZodString;
+    removed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    replicaId: string;
+    uid: string;
+    removed: boolean;
+    value?: any;
+}, {
+    timestamp: string;
+    replicaId: string;
+    uid: string;
+    value?: any;
+    removed?: boolean | undefined;
+}>;
+export type ORSetElement = z.infer<typeof ORSetElementSchema>;
+/**
+ * OR-Set Schema
+ * Observed-Remove Set CRDT
+ */
+export declare const ORSetSchema: z.ZodObject<{
+    type: z.ZodLiteral<"or-set">;
+    elements: z.ZodArray<z.ZodObject<{
+        value: z.ZodAny;
+        timestamp: z.ZodString;
+        replicaId: z.ZodString;
+        uid: z.ZodString;
+        removed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        removed: boolean;
+        value?: any;
+    }, {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        value?: any;
+        removed?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "or-set";
+    elements: {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        removed: boolean;
+        value?: any;
+    }[];
+}, {
+    type: "or-set";
+    elements: {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        value?: any;
+        removed?: boolean | undefined;
+    }[];
+}>;
+export type ORSet = z.infer<typeof ORSetSchema>;
+/**
+ * Text CRDT Operation Schema
+ * Operations for text-based CRDTs (e.g., Yjs, Automerge)
+ */
+export declare const TextCRDTOperationSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    replicaId: z.ZodString;
+    position: z.ZodNumber;
+    insert: z.ZodOptional<z.ZodString>;
+    delete: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodString;
+    lamportTimestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    position: number;
+    timestamp: string;
+    operationId: string;
+    replicaId: string;
+    lamportTimestamp: number;
+    insert?: string | undefined;
+    delete?: number | undefined;
+}, {
+    position: number;
+    timestamp: string;
+    operationId: string;
+    replicaId: string;
+    lamportTimestamp: number;
+    insert?: string | undefined;
+    delete?: number | undefined;
+}>;
+export type TextCRDTOperation = z.infer<typeof TextCRDTOperationSchema>;
+/**
+ * Text CRDT State Schema
+ * State of a text-based CRDT document
+ */
+export declare const TextCRDTStateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    documentId: z.ZodString;
+    content: z.ZodString;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        replicaId: z.ZodString;
+        position: z.ZodNumber;
+        insert: z.ZodOptional<z.ZodString>;
+        delete: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodString;
+        lamportTimestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }>, "many">;
+    lamportClock: z.ZodNumber;
+    vectorClock: z.ZodObject<{
+        clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        clock: Record<string, number>;
+    }, {
+        clock: Record<string, number>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    documentId: string;
+    vectorClock: {
+        clock: Record<string, number>;
+    };
+    content: string;
+    operations: {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }[];
+    lamportClock: number;
+}, {
+    type: "text";
+    documentId: string;
+    vectorClock: {
+        clock: Record<string, number>;
+    };
+    content: string;
+    operations: {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }[];
+    lamportClock: number;
+}>;
+export type TextCRDTState = z.infer<typeof TextCRDTStateSchema>;
+/**
+ * CRDT State Union
+ * Discriminated union of all CRDT types
+ */
+export declare const CRDTStateSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"lww-register">;
+    value: z.ZodAny;
+    timestamp: z.ZodString;
+    replicaId: z.ZodString;
+    vectorClock: z.ZodOptional<z.ZodObject<{
+        clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        clock: Record<string, number>;
+    }, {
+        clock: Record<string, number>;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "lww-register";
+    timestamp: string;
+    replicaId: string;
+    value?: any;
+    vectorClock?: {
+        clock: Record<string, number>;
+    } | undefined;
+}, {
+    type: "lww-register";
+    timestamp: string;
+    replicaId: string;
+    value?: any;
+    vectorClock?: {
+        clock: Record<string, number>;
+    } | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"g-counter">;
+    counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "g-counter";
+    counts: Record<string, number>;
+}, {
+    type: "g-counter";
+    counts: Record<string, number>;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pn-counter">;
+    positive: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    negative: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "pn-counter";
+    positive: Record<string, number>;
+    negative: Record<string, number>;
+}, {
+    type: "pn-counter";
+    positive: Record<string, number>;
+    negative: Record<string, number>;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"or-set">;
+    elements: z.ZodArray<z.ZodObject<{
+        value: z.ZodAny;
+        timestamp: z.ZodString;
+        replicaId: z.ZodString;
+        uid: z.ZodString;
+        removed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        removed: boolean;
+        value?: any;
+    }, {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        value?: any;
+        removed?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "or-set";
+    elements: {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        removed: boolean;
+        value?: any;
+    }[];
+}, {
+    type: "or-set";
+    elements: {
+        timestamp: string;
+        replicaId: string;
+        uid: string;
+        value?: any;
+        removed?: boolean | undefined;
+    }[];
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    documentId: z.ZodString;
+    content: z.ZodString;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        replicaId: z.ZodString;
+        position: z.ZodNumber;
+        insert: z.ZodOptional<z.ZodString>;
+        delete: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodString;
+        lamportTimestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }>, "many">;
+    lamportClock: z.ZodNumber;
+    vectorClock: z.ZodObject<{
+        clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        clock: Record<string, number>;
+    }, {
+        clock: Record<string, number>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    documentId: string;
+    vectorClock: {
+        clock: Record<string, number>;
+    };
+    content: string;
+    operations: {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }[];
+    lamportClock: number;
+}, {
+    type: "text";
+    documentId: string;
+    vectorClock: {
+        clock: Record<string, number>;
+    };
+    content: string;
+    operations: {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }[];
+    lamportClock: number;
+}>]>;
+export type CRDTState = z.infer<typeof CRDTStateSchema>;
+/**
+ * CRDT Merge Schema
+ * Result of merging two CRDT states
+ */
+export declare const CRDTMergeResultSchema: z.ZodObject<{
+    state: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"lww-register">;
+        value: z.ZodAny;
+        timestamp: z.ZodString;
+        replicaId: z.ZodString;
+        vectorClock: z.ZodOptional<z.ZodObject<{
+            clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            clock: Record<string, number>;
+        }, {
+            clock: Record<string, number>;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "lww-register";
+        timestamp: string;
+        replicaId: string;
+        value?: any;
+        vectorClock?: {
+            clock: Record<string, number>;
+        } | undefined;
+    }, {
+        type: "lww-register";
+        timestamp: string;
+        replicaId: string;
+        value?: any;
+        vectorClock?: {
+            clock: Record<string, number>;
+        } | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"g-counter">;
+        counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "g-counter";
+        counts: Record<string, number>;
+    }, {
+        type: "g-counter";
+        counts: Record<string, number>;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"pn-counter">;
+        positive: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        negative: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "pn-counter";
+        positive: Record<string, number>;
+        negative: Record<string, number>;
+    }, {
+        type: "pn-counter";
+        positive: Record<string, number>;
+        negative: Record<string, number>;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"or-set">;
+        elements: z.ZodArray<z.ZodObject<{
+            value: z.ZodAny;
+            timestamp: z.ZodString;
+            replicaId: z.ZodString;
+            uid: z.ZodString;
+            removed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            removed: boolean;
+            value?: any;
+        }, {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            value?: any;
+            removed?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "or-set";
+        elements: {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            removed: boolean;
+            value?: any;
+        }[];
+    }, {
+        type: "or-set";
+        elements: {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            value?: any;
+            removed?: boolean | undefined;
+        }[];
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        documentId: z.ZodString;
+        content: z.ZodString;
+        operations: z.ZodArray<z.ZodObject<{
+            operationId: z.ZodString;
+            replicaId: z.ZodString;
+            position: z.ZodNumber;
+            insert: z.ZodOptional<z.ZodString>;
+            delete: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodString;
+            lamportTimestamp: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }, {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }>, "many">;
+        lamportClock: z.ZodNumber;
+        vectorClock: z.ZodObject<{
+            clock: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            clock: Record<string, number>;
+        }, {
+            clock: Record<string, number>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        documentId: string;
+        vectorClock: {
+            clock: Record<string, number>;
+        };
+        content: string;
+        operations: {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }[];
+        lamportClock: number;
+    }, {
+        type: "text";
+        documentId: string;
+        vectorClock: {
+            clock: Record<string, number>;
+        };
+        content: string;
+        operations: {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }[];
+        lamportClock: number;
+    }>]>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+        resolved: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        description: string;
+        resolved: boolean;
+    }, {
+        type: string;
+        description: string;
+        resolved: boolean;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    state: {
+        type: "lww-register";
+        timestamp: string;
+        replicaId: string;
+        value?: any;
+        vectorClock?: {
+            clock: Record<string, number>;
+        } | undefined;
+    } | {
+        type: "g-counter";
+        counts: Record<string, number>;
+    } | {
+        type: "pn-counter";
+        positive: Record<string, number>;
+        negative: Record<string, number>;
+    } | {
+        type: "or-set";
+        elements: {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            removed: boolean;
+            value?: any;
+        }[];
+    } | {
+        type: "text";
+        documentId: string;
+        vectorClock: {
+            clock: Record<string, number>;
+        };
+        content: string;
+        operations: {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }[];
+        lamportClock: number;
+    };
+    conflicts?: {
+        type: string;
+        description: string;
+        resolved: boolean;
+    }[] | undefined;
+}, {
+    state: {
+        type: "lww-register";
+        timestamp: string;
+        replicaId: string;
+        value?: any;
+        vectorClock?: {
+            clock: Record<string, number>;
+        } | undefined;
+    } | {
+        type: "g-counter";
+        counts: Record<string, number>;
+    } | {
+        type: "pn-counter";
+        positive: Record<string, number>;
+        negative: Record<string, number>;
+    } | {
+        type: "or-set";
+        elements: {
+            timestamp: string;
+            replicaId: string;
+            uid: string;
+            value?: any;
+            removed?: boolean | undefined;
+        }[];
+    } | {
+        type: "text";
+        documentId: string;
+        vectorClock: {
+            clock: Record<string, number>;
+        };
+        content: string;
+        operations: {
+            position: number;
+            timestamp: string;
+            operationId: string;
+            replicaId: string;
+            lamportTimestamp: number;
+            insert?: string | undefined;
+            delete?: number | undefined;
+        }[];
+        lamportClock: number;
+    };
+    conflicts?: {
+        type: string;
+        description: string;
+        resolved: boolean;
+    }[] | undefined;
+}>;
+export type CRDTMergeResult = z.infer<typeof CRDTMergeResultSchema>;
+/**
+ * Cursor Color Preset Enum
+ * Standard color presets for cursor visualization
+ */
+export declare const CursorColorPreset: z.ZodEnum<["blue", "green", "red", "yellow", "purple", "orange", "pink", "teal", "indigo", "cyan"]>;
+export type CursorColorPreset = z.infer<typeof CursorColorPreset>;
+/**
+ * Cursor Style Schema
+ * Visual styling for collaborative cursors
+ */
+export declare const CursorStyleSchema: z.ZodObject<{
+    color: z.ZodUnion<[z.ZodEnum<["blue", "green", "red", "yellow", "purple", "orange", "pink", "teal", "indigo", "cyan"]>, z.ZodString]>;
+    opacity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    label: z.ZodOptional<z.ZodString>;
+    showLabel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    pulseOnUpdate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    opacity: number;
+    showLabel: boolean;
+    pulseOnUpdate: boolean;
+    label?: string | undefined;
+}, {
+    color: string;
+    label?: string | undefined;
+    opacity?: number | undefined;
+    showLabel?: boolean | undefined;
+    pulseOnUpdate?: boolean | undefined;
+}>;
+export type CursorStyle = z.infer<typeof CursorStyleSchema>;
+/**
+ * Cursor Selection Schema
+ * Represents a text selection in collaborative editing
+ */
+export declare const CursorSelectionSchema: z.ZodObject<{
+    anchor: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        column: number;
+        line: number;
+    }, {
+        column: number;
+        line: number;
+    }>;
+    focus: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        column: number;
+        line: number;
+    }, {
+        column: number;
+        line: number;
+    }>;
+    direction: z.ZodOptional<z.ZodEnum<["forward", "backward"]>>;
+}, "strip", z.ZodTypeAny, {
+    anchor: {
+        column: number;
+        line: number;
+    };
+    focus: {
+        column: number;
+        line: number;
+    };
+    direction?: "forward" | "backward" | undefined;
+}, {
+    anchor: {
+        column: number;
+        line: number;
+    };
+    focus: {
+        column: number;
+        line: number;
+    };
+    direction?: "forward" | "backward" | undefined;
+}>;
+export type CursorSelection = z.infer<typeof CursorSelectionSchema>;
+/**
+ * Collaborative Cursor Schema
+ * Complete cursor state for a collaborative user
+ */
+export declare const CollaborativeCursorSchema: z.ZodObject<{
+    userId: z.ZodString;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+    userName: z.ZodString;
+    position: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        column: number;
+        line: number;
+    }, {
+        column: number;
+        line: number;
+    }>;
+    selection: z.ZodOptional<z.ZodObject<{
+        anchor: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            column: number;
+            line: number;
+        }, {
+            column: number;
+            line: number;
+        }>;
+        focus: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            column: number;
+            line: number;
+        }, {
+            column: number;
+            line: number;
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<["forward", "backward"]>>;
+    }, "strip", z.ZodTypeAny, {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    }, {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    }>>;
+    style: z.ZodObject<{
+        color: z.ZodUnion<[z.ZodEnum<["blue", "green", "red", "yellow", "purple", "orange", "pink", "teal", "indigo", "cyan"]>, z.ZodString]>;
+        opacity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        label: z.ZodOptional<z.ZodString>;
+        showLabel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        pulseOnUpdate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        color: string;
+        opacity: number;
+        showLabel: boolean;
+        pulseOnUpdate: boolean;
+        label?: string | undefined;
+    }, {
+        color: string;
+        label?: string | undefined;
+        opacity?: number | undefined;
+        showLabel?: boolean | undefined;
+        pulseOnUpdate?: boolean | undefined;
+    }>;
+    isTyping: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    lastUpdate: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    position: {
+        column: number;
+        line: number;
+    };
+    documentId: string;
+    sessionId: string;
+    userName: string;
+    style: {
+        color: string;
+        opacity: number;
+        showLabel: boolean;
+        pulseOnUpdate: boolean;
+        label?: string | undefined;
+    };
+    isTyping: boolean;
+    lastUpdate: string;
+    metadata?: Record<string, any> | undefined;
+    selection?: {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    } | undefined;
+}, {
+    userId: string;
+    position: {
+        column: number;
+        line: number;
+    };
+    documentId: string;
+    sessionId: string;
+    userName: string;
+    style: {
+        color: string;
+        label?: string | undefined;
+        opacity?: number | undefined;
+        showLabel?: boolean | undefined;
+        pulseOnUpdate?: boolean | undefined;
+    };
+    lastUpdate: string;
+    metadata?: Record<string, any> | undefined;
+    selection?: {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    } | undefined;
+    isTyping?: boolean | undefined;
+}>;
+export type CollaborativeCursor = z.infer<typeof CollaborativeCursorSchema>;
+/**
+ * Cursor Update Schema
+ * Update to a collaborative cursor
+ */
+export declare const CursorUpdateSchema: z.ZodObject<{
+    position: z.ZodOptional<z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        column: number;
+        line: number;
+    }, {
+        column: number;
+        line: number;
+    }>>;
+    selection: z.ZodOptional<z.ZodObject<{
+        anchor: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            column: number;
+            line: number;
+        }, {
+            column: number;
+            line: number;
+        }>;
+        focus: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            column: number;
+            line: number;
+        }, {
+            column: number;
+            line: number;
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<["forward", "backward"]>>;
+    }, "strip", z.ZodTypeAny, {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    }, {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    }>>;
+    isTyping: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    metadata?: Record<string, any> | undefined;
+    selection?: {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    } | undefined;
+    position?: {
+        column: number;
+        line: number;
+    } | undefined;
+    isTyping?: boolean | undefined;
+}, {
+    metadata?: Record<string, any> | undefined;
+    selection?: {
+        anchor: {
+            column: number;
+            line: number;
+        };
+        focus: {
+            column: number;
+            line: number;
+        };
+        direction?: "forward" | "backward" | undefined;
+    } | undefined;
+    position?: {
+        column: number;
+        line: number;
+    } | undefined;
+    isTyping?: boolean | undefined;
+}>;
+export type CursorUpdate = z.infer<typeof CursorUpdateSchema>;
+/**
+ * User Activity Status Enum
+ * User activity status for awareness
+ */
+export declare const UserActivityStatus: z.ZodEnum<["active", "idle", "viewing", "disconnected"]>;
+export type UserActivityStatus = z.infer<typeof UserActivityStatus>;
+/**
+ * Awareness User State Schema
+ * Tracks what a user is doing in the collaborative session
+ */
+export declare const AwarenessUserStateSchema: z.ZodObject<{
+    userId: z.ZodString;
+    sessionId: z.ZodString;
+    userName: z.ZodString;
+    userAvatar: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["active", "idle", "viewing", "disconnected"]>;
+    currentDocument: z.ZodOptional<z.ZodString>;
+    currentView: z.ZodOptional<z.ZodString>;
+    lastActivity: z.ZodString;
+    joinedAt: z.ZodString;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "idle" | "viewing" | "disconnected";
+    userId: string;
+    sessionId: string;
+    userName: string;
+    lastActivity: string;
+    joinedAt: string;
+    metadata?: Record<string, any> | undefined;
+    userAvatar?: string | undefined;
+    currentDocument?: string | undefined;
+    currentView?: string | undefined;
+    permissions?: string[] | undefined;
+}, {
+    status: "active" | "idle" | "viewing" | "disconnected";
+    userId: string;
+    sessionId: string;
+    userName: string;
+    lastActivity: string;
+    joinedAt: string;
+    metadata?: Record<string, any> | undefined;
+    userAvatar?: string | undefined;
+    currentDocument?: string | undefined;
+    currentView?: string | undefined;
+    permissions?: string[] | undefined;
+}>;
+export type AwarenessUserState = z.infer<typeof AwarenessUserStateSchema>;
+/**
+ * Awareness Session Schema
+ * Represents the complete awareness state for a collaboration session
+ */
+export declare const AwarenessSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    documentId: z.ZodOptional<z.ZodString>;
+    users: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        sessionId: z.ZodString;
+        userName: z.ZodString;
+        userAvatar: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<["active", "idle", "viewing", "disconnected"]>;
+        currentDocument: z.ZodOptional<z.ZodString>;
+        currentView: z.ZodOptional<z.ZodString>;
+        lastActivity: z.ZodString;
+        joinedAt: z.ZodString;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }, {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }>, "many">;
+    startedAt: z.ZodString;
+    lastUpdate: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    startedAt: string;
+    users: {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }[];
+    sessionId: string;
+    lastUpdate: string;
+    metadata?: Record<string, any> | undefined;
+    documentId?: string | undefined;
+}, {
+    startedAt: string;
+    users: {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }[];
+    sessionId: string;
+    lastUpdate: string;
+    metadata?: Record<string, any> | undefined;
+    documentId?: string | undefined;
+}>;
+export type AwarenessSession = z.infer<typeof AwarenessSessionSchema>;
+/**
+ * Awareness Update Schema
+ * Update to awareness state
+ */
+export declare const AwarenessUpdateSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["active", "idle", "viewing", "disconnected"]>>;
+    currentDocument: z.ZodOptional<z.ZodString>;
+    currentView: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "idle" | "viewing" | "disconnected" | undefined;
+    metadata?: Record<string, any> | undefined;
+    currentDocument?: string | undefined;
+    currentView?: string | undefined;
+}, {
+    status?: "active" | "idle" | "viewing" | "disconnected" | undefined;
+    metadata?: Record<string, any> | undefined;
+    currentDocument?: string | undefined;
+    currentView?: string | undefined;
+}>;
+export type AwarenessUpdate = z.infer<typeof AwarenessUpdateSchema>;
+/**
+ * Awareness Event Schema
+ * Events that occur in awareness tracking
+ */
+export declare const AwarenessEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    sessionId: z.ZodString;
+    eventType: z.ZodEnum<["user.joined", "user.left", "user.updated", "session.created", "session.ended"]>;
+    userId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    payload: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    eventType: "user.joined" | "user.left" | "user.updated" | "session.created" | "session.ended";
+    timestamp: string;
+    sessionId: string;
+    eventId: string;
+    userId?: string | undefined;
+    payload?: any;
+}, {
+    eventType: "user.joined" | "user.left" | "user.updated" | "session.created" | "session.ended";
+    timestamp: string;
+    sessionId: string;
+    eventId: string;
+    userId?: string | undefined;
+    payload?: any;
+}>;
+export type AwarenessEvent = z.infer<typeof AwarenessEventSchema>;
+/**
+ * Collaboration Mode Enum
+ * Types of collaboration modes
+ */
+export declare const CollaborationMode: z.ZodEnum<["ot", "crdt", "lock", "hybrid"]>;
+export type CollaborationMode = z.infer<typeof CollaborationMode>;
+/**
+ * Collaboration Session Config
+ * Configuration for a collaboration session
+ */
+export declare const CollaborationSessionConfigSchema: z.ZodObject<{
+    mode: z.ZodEnum<["ot", "crdt", "lock", "hybrid"]>;
+    enableCursorSharing: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enablePresence: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableAwareness: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxUsers: z.ZodOptional<z.ZodNumber>;
+    idleTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<["ot", "crdt", "manual"]>>>;
+    persistence: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        interval: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        interval: number;
+    }, {
+        enabled: boolean;
+        interval: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    mode: "hybrid" | "ot" | "crdt" | "lock";
+    persistence: boolean;
+    enableCursorSharing: boolean;
+    enablePresence: boolean;
+    enableAwareness: boolean;
+    idleTimeout: number;
+    conflictResolution: "ot" | "crdt" | "manual";
+    snapshot?: {
+        enabled: boolean;
+        interval: number;
+    } | undefined;
+    maxUsers?: number | undefined;
+}, {
+    mode: "hybrid" | "ot" | "crdt" | "lock";
+    snapshot?: {
+        enabled: boolean;
+        interval: number;
+    } | undefined;
+    persistence?: boolean | undefined;
+    enableCursorSharing?: boolean | undefined;
+    enablePresence?: boolean | undefined;
+    enableAwareness?: boolean | undefined;
+    maxUsers?: number | undefined;
+    idleTimeout?: number | undefined;
+    conflictResolution?: "ot" | "crdt" | "manual" | undefined;
+}>;
+export type CollaborationSessionConfig = z.infer<typeof CollaborationSessionConfigSchema>;
+/**
+ * Collaboration Session Schema
+ * Complete collaboration session state
+ */
+export declare const CollaborationSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+    config: z.ZodObject<{
+        mode: z.ZodEnum<["ot", "crdt", "lock", "hybrid"]>;
+        enableCursorSharing: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enablePresence: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enableAwareness: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxUsers: z.ZodOptional<z.ZodNumber>;
+        idleTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<["ot", "crdt", "manual"]>>>;
+        persistence: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        snapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            interval: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            interval: number;
+        }, {
+            enabled: boolean;
+            interval: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "hybrid" | "ot" | "crdt" | "lock";
+        persistence: boolean;
+        enableCursorSharing: boolean;
+        enablePresence: boolean;
+        enableAwareness: boolean;
+        idleTimeout: number;
+        conflictResolution: "ot" | "crdt" | "manual";
+        snapshot?: {
+            enabled: boolean;
+            interval: number;
+        } | undefined;
+        maxUsers?: number | undefined;
+    }, {
+        mode: "hybrid" | "ot" | "crdt" | "lock";
+        snapshot?: {
+            enabled: boolean;
+            interval: number;
+        } | undefined;
+        persistence?: boolean | undefined;
+        enableCursorSharing?: boolean | undefined;
+        enablePresence?: boolean | undefined;
+        enableAwareness?: boolean | undefined;
+        maxUsers?: number | undefined;
+        idleTimeout?: number | undefined;
+        conflictResolution?: "ot" | "crdt" | "manual" | undefined;
+    }>;
+    users: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        sessionId: z.ZodString;
+        userName: z.ZodString;
+        userAvatar: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<["active", "idle", "viewing", "disconnected"]>;
+        currentDocument: z.ZodOptional<z.ZodString>;
+        currentView: z.ZodOptional<z.ZodString>;
+        lastActivity: z.ZodString;
+        joinedAt: z.ZodString;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }, {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }>, "many">;
+    cursors: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        sessionId: z.ZodString;
+        documentId: z.ZodString;
+        userName: z.ZodString;
+        position: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            column: number;
+            line: number;
+        }, {
+            column: number;
+            line: number;
+        }>;
+        selection: z.ZodOptional<z.ZodObject<{
+            anchor: z.ZodObject<{
+                line: z.ZodNumber;
+                column: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                column: number;
+                line: number;
+            }, {
+                column: number;
+                line: number;
+            }>;
+            focus: z.ZodObject<{
+                line: z.ZodNumber;
+                column: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                column: number;
+                line: number;
+            }, {
+                column: number;
+                line: number;
+            }>;
+            direction: z.ZodOptional<z.ZodEnum<["forward", "backward"]>>;
+        }, "strip", z.ZodTypeAny, {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        }, {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        }>>;
+        style: z.ZodObject<{
+            color: z.ZodUnion<[z.ZodEnum<["blue", "green", "red", "yellow", "purple", "orange", "pink", "teal", "indigo", "cyan"]>, z.ZodString]>;
+            opacity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            label: z.ZodOptional<z.ZodString>;
+            showLabel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            pulseOnUpdate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            color: string;
+            opacity: number;
+            showLabel: boolean;
+            pulseOnUpdate: boolean;
+            label?: string | undefined;
+        }, {
+            color: string;
+            label?: string | undefined;
+            opacity?: number | undefined;
+            showLabel?: boolean | undefined;
+            pulseOnUpdate?: boolean | undefined;
+        }>;
+        isTyping: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        lastUpdate: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        position: {
+            column: number;
+            line: number;
+        };
+        documentId: string;
+        sessionId: string;
+        userName: string;
+        style: {
+            color: string;
+            opacity: number;
+            showLabel: boolean;
+            pulseOnUpdate: boolean;
+            label?: string | undefined;
+        };
+        isTyping: boolean;
+        lastUpdate: string;
+        metadata?: Record<string, any> | undefined;
+        selection?: {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        } | undefined;
+    }, {
+        userId: string;
+        position: {
+            column: number;
+            line: number;
+        };
+        documentId: string;
+        sessionId: string;
+        userName: string;
+        style: {
+            color: string;
+            label?: string | undefined;
+            opacity?: number | undefined;
+            showLabel?: boolean | undefined;
+            pulseOnUpdate?: boolean | undefined;
+        };
+        lastUpdate: string;
+        metadata?: Record<string, any> | undefined;
+        selection?: {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        } | undefined;
+        isTyping?: boolean | undefined;
+    }>, "many">;
+    version: z.ZodNumber;
+    operations: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        operationId: z.ZodString;
+        documentId: z.ZodString;
+        userId: z.ZodString;
+        sessionId: z.ZodString;
+        components: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"insert">;
+            text: z.ZodString;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        }, {
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"delete">;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: "delete";
+            count: number;
+        }, {
+            type: "delete";
+            count: number;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"retain">;
+            count: z.ZodNumber;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        }, {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        }>]>, "many">;
+        baseVersion: z.ZodNumber;
+        timestamp: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    }>, z.ZodObject<{
+        operationId: z.ZodString;
+        replicaId: z.ZodString;
+        position: z.ZodNumber;
+        insert: z.ZodOptional<z.ZodString>;
+        delete: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodString;
+        lamportTimestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }, {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    }>]>, "many">>;
+    createdAt: z.ZodString;
+    lastActivity: z.ZodString;
+    status: z.ZodEnum<["active", "idle", "ended"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "idle" | "ended";
+    version: number;
+    createdAt: string;
+    config: {
+        mode: "hybrid" | "ot" | "crdt" | "lock";
+        persistence: boolean;
+        enableCursorSharing: boolean;
+        enablePresence: boolean;
+        enableAwareness: boolean;
+        idleTimeout: number;
+        conflictResolution: "ot" | "crdt" | "manual";
+        snapshot?: {
+            enabled: boolean;
+            interval: number;
+        } | undefined;
+        maxUsers?: number | undefined;
+    };
+    users: {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }[];
+    documentId: string;
+    sessionId: string;
+    lastActivity: string;
+    cursors: {
+        userId: string;
+        position: {
+            column: number;
+            line: number;
+        };
+        documentId: string;
+        sessionId: string;
+        userName: string;
+        style: {
+            color: string;
+            opacity: number;
+            showLabel: boolean;
+            pulseOnUpdate: boolean;
+            label?: string | undefined;
+        };
+        isTyping: boolean;
+        lastUpdate: string;
+        metadata?: Record<string, any> | undefined;
+        selection?: {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        } | undefined;
+    }[];
+    operations?: ({
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    } | {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    })[] | undefined;
+}, {
+    status: "active" | "idle" | "ended";
+    version: number;
+    createdAt: string;
+    config: {
+        mode: "hybrid" | "ot" | "crdt" | "lock";
+        snapshot?: {
+            enabled: boolean;
+            interval: number;
+        } | undefined;
+        persistence?: boolean | undefined;
+        enableCursorSharing?: boolean | undefined;
+        enablePresence?: boolean | undefined;
+        enableAwareness?: boolean | undefined;
+        maxUsers?: number | undefined;
+        idleTimeout?: number | undefined;
+        conflictResolution?: "ot" | "crdt" | "manual" | undefined;
+    };
+    users: {
+        status: "active" | "idle" | "viewing" | "disconnected";
+        userId: string;
+        sessionId: string;
+        userName: string;
+        lastActivity: string;
+        joinedAt: string;
+        metadata?: Record<string, any> | undefined;
+        userAvatar?: string | undefined;
+        currentDocument?: string | undefined;
+        currentView?: string | undefined;
+        permissions?: string[] | undefined;
+    }[];
+    documentId: string;
+    sessionId: string;
+    lastActivity: string;
+    cursors: {
+        userId: string;
+        position: {
+            column: number;
+            line: number;
+        };
+        documentId: string;
+        sessionId: string;
+        userName: string;
+        style: {
+            color: string;
+            label?: string | undefined;
+            opacity?: number | undefined;
+            showLabel?: boolean | undefined;
+            pulseOnUpdate?: boolean | undefined;
+        };
+        lastUpdate: string;
+        metadata?: Record<string, any> | undefined;
+        selection?: {
+            anchor: {
+                column: number;
+                line: number;
+            };
+            focus: {
+                column: number;
+                line: number;
+            };
+            direction?: "forward" | "backward" | undefined;
+        } | undefined;
+        isTyping?: boolean | undefined;
+    }[];
+    operations?: ({
+        userId: string;
+        components: ({
+            type: "insert";
+            text: string;
+            attributes?: Record<string, any> | undefined;
+        } | {
+            type: "delete";
+            count: number;
+        } | {
+            type: "retain";
+            count: number;
+            attributes?: Record<string, any> | undefined;
+        })[];
+        timestamp: string;
+        operationId: string;
+        documentId: string;
+        sessionId: string;
+        baseVersion: number;
+        metadata?: Record<string, any> | undefined;
+    } | {
+        position: number;
+        timestamp: string;
+        operationId: string;
+        replicaId: string;
+        lamportTimestamp: number;
+        insert?: string | undefined;
+        delete?: number | undefined;
+    })[] | undefined;
+}>;
+export type CollaborationSession = z.infer<typeof CollaborationSessionSchema>;
+//# sourceMappingURL=collaboration.zod.d.ts.map