@mdxui/terminal 2.0.0

package/dist/data/index.d.ts

@@ -0,0 +1,2554 @@
+import { ZodSchema, z } from 'zod';
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * @mdxui/terminal Data Layer Types
+ *
+ * Type definitions for the TanStack DB-like integration.
+ * Provides a type-safe, reactive in-memory database with Zod validation,
+ * filtering, sorting, pagination, and optimistic updates.
+ */
+
+/**
+ * Comparison operators for filtering database queries
+ *
+ * @template T - The type of the field being compared
+ *
+ * @example
+ * ```typescript
+ * // Using comparison operators in a where clause
+ * {
+ *   $eq: 5,           // Equal to 5
+ *   $ne: 10,          // Not equal to 10
+ *   $gt: 3,           // Greater than 3
+ *   $gte: 3,          // Greater than or equal to 3
+ *   $lt: 100,         // Less than 100
+ *   $lte: 100,        // Less than or equal to 100
+ *   $in: [1, 2, 3],   // In array [1, 2, 3]
+ *   $nin: [1, 2, 3],  // Not in array [1, 2, 3]
+ * }
+ * ```
+ */
+interface ComparisonOperators<T> {
+    /** Equality match */
+    $eq?: T;
+    /** Not equal to */
+    $ne?: T;
+    /** Greater than */
+    $gt?: T;
+    /** Greater than or equal to */
+    $gte?: T;
+    /** Less than */
+    $lt?: T;
+    /** Less than or equal to */
+    $lte?: T;
+    /** Value is in array */
+    $in?: T[];
+    /** Value is not in array */
+    $nin?: T[];
+}
+/**
+ * Field filter - either a direct value for equality or comparison operators
+ *
+ * @template T - The type of the field
+ *
+ * @example
+ * ```typescript
+ * // Direct equality
+ * type Filter = FieldFilter<number>  // number
+ * const filter: Filter = 5
+ *
+ * // With operators
+ * const filter: Filter = { $gt: 5 }
+ * ```
+ */
+type FieldFilter<T> = T | ComparisonOperators<T>;
+/**
+ * Where clause for filtering - supports equality, comparison operators, and $or
+ *
+ * @template T - The document type being queried
+ *
+ * @remarks
+ * - Uses AND logic for multiple field conditions
+ * - `$or` is an array of alternative conditions (OR logic)
+ * - Can combine $or with other fields (fields AND ($or[...]))
+ *
+ * @example
+ * ```typescript
+ * // Simple equality
+ * const where: WhereClause<User> = { role: 'admin' }
+ *
+ * // With comparison operators
+ * const where: WhereClause<User> = { age: { $gte: 18 } }
+ *
+ * // Multiple conditions (AND)
+ * const where: WhereClause<User> = {
+ *   role: 'admin',
+ *   age: { $gte: 18 }
+ * }
+ *
+ * // OR conditions
+ * const where: WhereClause<User> = {
+ *   $or: [
+ *     { role: 'admin' },
+ *     { role: 'moderator' }
+ *   ]
+ * }
+ *
+ * // Combined AND/OR
+ * const where: WhereClause<User> = {
+ *   status: 'active',
+ *   $or: [
+ *     { role: 'admin' },
+ *     { role: 'moderator' }
+ *   ]
+ * }
+ * ```
+ */
+type WhereClause<T> = {
+    [K in keyof T]?: FieldFilter<T[K]>;
+} & {
+    $or?: Array<WhereClause<T>>;
+};
+/**
+ * Sort direction for ordering results
+ *
+ * @example
+ * ```typescript
+ * type Direction = OrderDirection
+ * const ascending: Direction = 'asc'
+ * const descending: Direction = 'desc'
+ * ```
+ */
+type OrderDirection = 'asc' | 'desc';
+/**
+ * Order by clause for sorting results
+ *
+ * @template T - The document type being sorted
+ *
+ * @remarks
+ * Maps field names to sort directions (asc/desc)
+ *
+ * @example
+ * ```typescript
+ * // Sort by age ascending
+ * const orderBy: OrderByClause<User> = { age: 'asc' }
+ *
+ * // Sort by multiple fields
+ * const orderByArray: OrderByClause<User>[] = [
+ *   { role: 'asc' },
+ *   { age: 'desc' }
+ * ]
+ * ```
+ */
+type OrderByClause<T> = {
+    [K in keyof T]?: OrderDirection;
+};
+/**
+ * A typed in-memory collection with CRUD operations, filtering, sorting, and reactive subscriptions
+ *
+ * @template T - The document type stored in this collection
+ *
+ * @remarks
+ * - All documents are validated against the schema on insert/update
+ * - Provides reactive subscriptions for real-time updates
+ * - Supports filtering with where clauses and comparison operators
+ * - Supports sorting with orderBy and multiple sort fields
+ * - Supports pagination with limit and offset
+ *
+ * @example
+ * ```typescript
+ * const collection = createCollection<User>({
+ *   name: 'users',
+ *   schema: UserSchema
+ * })
+ *
+ * // CRUD operations
+ * const user = await collection.insert({ id: '1', name: 'Alice', ... })
+ * const updated = await collection.update({ id: '1' }, { name: 'Alicia' })
+ * const found = await collection.findOne({ id: '1' })
+ * const all = await collection.findMany()
+ * await collection.delete({ id: '1' })
+ *
+ * // Subscribe to changes
+ * const unsubscribe = collection.subscribe((data) => {
+ *   console.log('Collection changed:', data)
+ * })
+ * ```
+ */
+interface Collection<T> {
+    /** Collection name - used to reference in queries */
+    name: string;
+    /** Zod schema for validation */
+    schema: ZodSchema<T>;
+    /** Primary key field name */
+    primaryKey: string;
+    /** Indexed field names */
+    indexes: string[];
+    /**
+     * Insert a new document into the collection
+     *
+     * @param data - Document to insert (must match schema)
+     * @returns The validated document
+     * @throws If document fails schema validation or primary key already exists
+     */
+    insert(data: T): Promise<T>;
+    /**
+     * Update one or more documents matching the filter
+     *
+     * @param filter - Documents matching this filter will be updated
+     * @param data - Partial updates to apply (merged with existing data)
+     * @returns Array of updated documents
+     * @throws If updated documents fail schema validation
+     */
+    update(filter: Partial<T>, data: Partial<T>): Promise<T[]>;
+    /**
+     * Delete one or more documents matching the filter
+     *
+     * @param filter - Documents matching this filter will be deleted
+     * @returns void
+     */
+    delete(filter: Partial<T>): Promise<void>;
+    /**
+     * Find a single document matching the filter
+     *
+     * @param filter - Equality filter conditions
+     * @returns First matching document or null if not found
+     */
+    findOne(filter: Partial<T>): Promise<T | null>;
+    /**
+     * Find multiple documents with optional filtering, sorting, and pagination
+     *
+     * @param options - Query options (where, orderBy, limit, offset)
+     * @returns Array of matching documents
+     *
+     * @example
+     * ```typescript
+     * // Get all
+     * const all = await collection.findMany()
+     *
+     * // With filter
+     * const admins = await collection.findMany({
+     *   where: { role: 'admin' }
+     * })
+     *
+     * // With sorting and pagination
+     * const page = await collection.findMany({
+     *   where: { status: 'active' },
+     *   orderBy: { createdAt: 'desc' },
+     *   limit: 20,
+     *   offset: 0
+     * })
+     * ```
+     */
+    findMany(options?: FindManyOptions<T>): Promise<T[]>;
+    /**
+     * Subscribe to collection changes
+     *
+     * @param callback - Called whenever data changes with current full collection state
+     * @returns Unsubscribe function to remove listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = collection.subscribe((data) => {
+     *   console.log('Collection now contains:', data)
+     * })
+     *
+     * // Later: stop listening
+     * unsubscribe()
+     * ```
+     */
+    subscribe(callback: (data: T[]) => void): () => void;
+    /** Internal: notify all subscribers of changes */
+    _notify(): void;
+}
+/**
+ * Sync adapter interface for remote synchronization
+ *
+ * @remarks
+ * Implement this interface to add custom sync behavior (WebSockets, server polling, etc.)
+ * The database automatically calls these methods when mutations occur (if optimistic mode enabled)
+ *
+ * @example
+ * ```typescript
+ * const syncAdapter: SyncAdapter = {
+ *   async push(changes) {
+ *     // Send to server
+ *     await fetch('/api/sync', { method: 'POST', body: JSON.stringify(changes) })
+ *   },
+ *   async pull() {
+ *     // Get from server
+ *     const res = await fetch('/api/sync')
+ *     return res.json()
+ *   },
+ *   subscribe(callback) {
+ *     // Listen for remote changes
+ *     const ws = new WebSocket('wss://...')
+ *     ws.onmessage = (e) => callback(e.data)
+ *     return () => ws.close()
+ *   }
+ * }
+ * ```
+ */
+interface SyncAdapter {
+    /**
+     * Push local changes to remote
+     *
+     * @param changes - Array of change objects to send to remote
+     * @throws Error if push fails - mutation will be rolled back if optimistic
+     */
+    push(changes: unknown[]): Promise<void>;
+    /**
+     * Pull remote changes
+     *
+     * @returns Array of changes from remote
+     */
+    pull(): Promise<unknown[]>;
+    /**
+     * Subscribe to remote changes
+     *
+     * @param callback - Called with remote changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (changes: unknown[]) => void): () => void;
+}
+/**
+ * Database configuration for creating a DB instance
+ *
+ * @example
+ * ```typescript
+ * const config: DBConfig = {
+ *   collections: [usersCollection, todosCollection],
+ *   sync: customSyncAdapter
+ * }
+ * ```
+ */
+interface DBConfig {
+    /** Collections to register in the database */
+    collections?: Collection<any>[];
+    /** Optional sync adapter for remote synchronization */
+    sync?: SyncAdapter;
+}
+/**
+ * Database instance - main entry point for accessing collections and syncing
+ *
+ * @remarks
+ * - Collections are accessed by name via `db.collections[name]`
+ * - Provides centralized management of all collections
+ * - Optional sync adapter for remote data synchronization
+ *
+ * @example
+ * ```typescript
+ * const db = createDB({
+ *   collections: [usersCollection, todosCollection],
+ *   sync: syncAdapter
+ * })
+ *
+ * // Access collections
+ * const users = await db.collections.users.findMany()
+ *
+ * // Clear all data
+ * await db.clear()
+ *
+ * // Close resources
+ * db.close()
+ * ```
+ */
+interface DB {
+    /** Registered collections by name - access with `db.collections[collectionName]` */
+    collections: Record<string, Collection<any>>;
+    /** Optional sync adapter if configured */
+    sync?: SyncAdapter;
+    /**
+     * Close the database connection and clean up resources
+     */
+    close(): void;
+    /**
+     * Clear all data from all collections
+     *
+     * @returns Promise that resolves when all data is cleared
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Options for collection.findMany() - internal collection query
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Unlike `QueryOptions`, this doesn't include `from` since it's called on a collection directly
+ *
+ * @example
+ * ```typescript
+ * const options: FindManyOptions<User> = {
+ *   where: { role: 'admin' },
+ *   orderBy: { name: 'asc' },
+ *   limit: 10,
+ *   offset: 0
+ * }
+ * const users = await collection.findMany(options)
+ * ```
+ */
+interface FindManyOptions<T> {
+    /** Filter conditions using WhereClause syntax */
+    where?: WhereClause<T>;
+    /** Sort order - single field or array of fields with directions */
+    orderBy?: OrderByClause<T> | OrderByClause<T>[];
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Number of results to skip (for pagination) */
+    offset?: number;
+}
+/**
+ * Options for useQuery hook - React hook query interface
+ *
+ * @template T - The document type being queried
+ *
+ * @remarks
+ * Extends `FindManyOptions` with `from` to specify which collection to query.
+ * Called within a `DBProvider` context.
+ *
+ * @example
+ * ```typescript
+ * const { data, isLoading, error } = useQuery<User>({
+ *   from: 'users',
+ *   where: { role: 'admin', age: { $gte: 18 } },
+ *   orderBy: { name: 'asc' },
+ *   limit: 20
+ * })
+ * ```
+ */
+interface QueryOptions<T> extends FindManyOptions<T> {
+    /** Collection name to query from */
+    from: string;
+}
+/**
+ * Result of useQuery hook - reactive query state and refetch control
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * - `data` starts as undefined while loading
+ * - `isLoading` is true until first query completes
+ * - Automatically updates when collection changes (reactive)
+ * - Subscribe callbacks automatically re-apply filters and sorting
+ *
+ * @example
+ * ```typescript
+ * const { data, isLoading, error, refetch } = useQuery<User>({
+ *   from: 'users'
+ * })
+ *
+ * if (isLoading) return <Spinner />
+ * if (error) return <Error message={error.message} />
+ *
+ * return (
+ *   <div>
+ *     {data?.map(user => (
+ *       <UserCard key={user.id} user={user} />
+ *     ))}
+ *     <button onClick={refetch}>Refresh</button>
+ *   </div>
+ * )
+ * ```
+ */
+interface QueryResult<T> {
+    /** Query results - undefined while loading, array when loaded */
+    data: T[] | undefined;
+    /** True while initial query is executing */
+    isLoading: boolean;
+    /** Error object if query failed, undefined if successful */
+    error: Error | undefined;
+    /** Function to manually refetch the query */
+    refetch: () => void;
+}
+/**
+ * Type of mutation operation
+ *
+ * @example
+ * ```typescript
+ * type Op = MutationOperation
+ * const operation: Op = 'insert'
+ * ```
+ */
+type MutationOperation = 'insert' | 'update' | 'delete';
+/**
+ * Options for useMutation hook
+ *
+ * @remarks
+ * - `insert`: Creates new document
+ * - `update`: Updates existing documents matching filter
+ * - `delete`: Removes documents matching filter
+ * - `optimistic`: If true, updates UI immediately before server confirmation
+ *   (on error, automatically rolls back)
+ *
+ * @example
+ * ```typescript
+ * const { mutate, isPending, error } = useMutation({
+ *   collection: 'users',
+ *   operation: 'insert',
+ *   optimistic: true
+ * })
+ * ```
+ */
+interface MutationOptions {
+    /** Collection name to mutate */
+    collection: string;
+    /** Type of operation: insert, update, or delete */
+    operation: MutationOperation;
+    /** Enable optimistic updates (show change immediately, rollback on error) */
+    optimistic?: boolean;
+}
+/**
+ * Data format for update mutations
+ *
+ * @template T - The document type
+ *
+ * @example
+ * ```typescript
+ * const updateData: UpdateMutationData<User> = {
+ *   where: { id: '1' },
+ *   data: { name: 'Updated Name' }
+ * }
+ * ```
+ */
+interface UpdateMutationData<T> {
+    /** Filter to select which documents to update */
+    where: Partial<T>;
+    /** Partial updates to apply to matching documents */
+    data: Partial<T>;
+}
+/**
+ * Data format for delete mutations
+ *
+ * @template T - The document type (generic for flexibility)
+ *
+ * @example
+ * ```typescript
+ * const deleteData: DeleteMutationData<User> = {
+ *   id: 'user-123'
+ * }
+ * ```
+ */
+interface DeleteMutationData<T> {
+    /** ID of document to delete */
+    id: string;
+}
+/**
+ * Result of useMutation hook - mutation execution and state control
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * - Call `mutate()` with data to execute the operation
+ * - `isPending` is true while mutation is executing
+ * - On error, `error` contains the Error object
+ * - Use `reset()` to clear error state after handling
+ * - For optimistic updates, local UI updates immediately
+ *   (automatic rollback if sync fails)
+ *
+ * @example
+ * ```typescript
+ * const { mutate, isPending, error, reset } = useMutation<User>({
+ *   collection: 'users',
+ *   operation: 'insert'
+ * })
+ *
+ * const handleCreate = async () => {
+ *   try {
+ *     await mutate({
+ *       id: '2',
+ *       name: 'Bob',
+ *       email: 'bob@example.com',
+ *       role: 'user'
+ *     })
+ *   } catch (err) {
+ *     console.error('Failed:', err)
+ *   }
+ * }
+ *
+ * return (
+ *   <form onSubmit={handleCreate}>
+ *     <button disabled={isPending}>
+ *       {isPending ? 'Creating...' : 'Create'}
+ *     </button>
+ *     {error && <Error message={error.message} onDismiss={reset} />}
+ *   </form>
+ * )
+ * ```
+ */
+interface MutationResult<T> {
+    /**
+     * Execute the mutation with data
+     * Data format depends on operation: T for insert, UpdateMutationData<T> for update, DeleteMutationData<T> for delete
+     */
+    mutate: (data: T | UpdateMutationData<T> | DeleteMutationData<T>) => Promise<void>;
+    /** True while mutation is being executed */
+    isPending: boolean;
+    /** Error object if mutation failed, undefined if successful */
+    error: Error | undefined;
+    /** Reset mutation state (clears error and pending flags) */
+    reset: () => void;
+}
+
+/**
+ * @mdxui/terminal Database Implementation
+ *
+ * In-memory database with collection management, sync adapter support,
+ * and centralized data access for React applications.
+ */
+
+/**
+ * Create a database instance with collections and optional sync adapter
+ *
+ * @param config - Database configuration with collections and sync adapter
+ * @returns A fully typed database instance for accessing collections
+ *
+ * @remarks
+ * - Collections are accessed via `db.collections[name]`
+ * - All data is stored in-memory (cleared on process exit)
+ * - Optional sync adapter can push/pull changes to a remote backend
+ * - Use within `DBProvider` for React applications
+ * - Thread-safe for concurrent operations
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ * import { createDB, createCollection } from '@mdxui/terminal'
+ *
+ * // Define schemas
+ * const UserSchema = z.object({
+ *   id: z.string(),
+ *   name: z.string(),
+ *   email: z.string().email(),
+ *   role: z.enum(['admin', 'user', 'guest'])
+ * })
+ *
+ * // Create collections
+ * const usersCollection = createCollection({
+ *   name: 'users',
+ *   schema: UserSchema,
+ *   primaryKey: 'id'
+ * })
+ *
+ * // Create database with collections
+ * const db = createDB({
+ *   collections: [usersCollection],
+ *   sync: customSyncAdapter // optional
+ * })
+ *
+ * // Access collections
+ * const user = await db.collections.users.insert({
+ *   id: '1',
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   role: 'admin'
+ * })
+ *
+ * const all = await db.collections.users.findMany()
+ * const admins = await db.collections.users.findMany({
+ *   where: { role: 'admin' }
+ * })
+ *
+ * // Clean up
+ * await db.clear()
+ * db.close()
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With sync adapter for remote sync
+ * const syncAdapter = {
+ *   async push(changes) {
+ *     await fetch('/api/sync', {
+ *       method: 'POST',
+ *       body: JSON.stringify(changes)
+ *     })
+ *   },
+ *   async pull() {
+ *     const res = await fetch('/api/sync')
+ *     return res.json()
+ *   },
+ *   subscribe(callback) {
+ *     const ws = new WebSocket('wss://...')
+ *     ws.onmessage = (e) => callback(e.data)
+ *     return () => ws.close()
+ *   }
+ * }
+ *
+ * const db = createDB({
+ *   collections: [usersCollection],
+ *   sync: syncAdapter
+ * })
+ * ```
+ */
+declare function createDB(config?: DBConfig): DB;
+
+/**
+ * @mdxui/terminal Collection Implementation
+ *
+ * In-memory collection with Zod validation, reactive subscriptions, filtering,
+ * sorting, and pagination support. Provides full CRUD operations with type safety.
+ */
+
+/**
+ * Configuration for creating a collection
+ *
+ * @template T - The document type stored in this collection
+ *
+ * @example
+ * ```typescript
+ * const config: CreateCollectionConfig<User> = {
+ *   name: 'users',
+ *   schema: UserSchema,
+ *   primaryKey: 'id',
+ *   indexes: ['email', 'role']
+ * }
+ * ```
+ */
+interface CreateCollectionConfig<T> {
+    /** Collection name - used to reference in queries and mutations */
+    name: string;
+    /** Zod schema for automatic validation on all insert/update operations */
+    schema: ZodSchema<T>;
+    /** Primary key field (defaults to 'id'). Used for duplicate detection */
+    primaryKey?: string;
+    /** Fields to index for faster queries (metadata only for future optimization) */
+    indexes?: string[];
+}
+/**
+ * Create a typed in-memory collection with Zod validation
+ *
+ * @template T - The document type (must be a Record for proper typing)
+ *
+ * @param config - Collection configuration (name, schema, primaryKey, indexes)
+ * @returns A fully typed collection instance with CRUD operations and subscriptions
+ *
+ * @remarks
+ * - All documents are validated against the provided Zod schema on insert/update
+ * - Primary key defaults to 'id' if not specified
+ * - Provides reactive subscriptions for real-time updates
+ * - Supports filtering with where clauses and comparison operators
+ * - Supports sorting with orderBy and multiple sort fields
+ * - Supports pagination with limit and offset
+ * - Thread-safe for concurrent operations (in-memory only)
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ * import { createCollection } from '@mdxui/terminal'
+ *
+ * // Define schema
+ * const UserSchema = z.object({
+ *   id: z.string(),
+ *   name: z.string(),
+ *   email: z.string().email(),
+ *   age: z.number().optional(),
+ *   role: z.enum(['admin', 'user', 'guest'])
+ * })
+ *
+ * type User = z.infer<typeof UserSchema>
+ *
+ * // Create collection
+ * const users = createCollection<User>({
+ *   name: 'users',
+ *   schema: UserSchema,
+ *   primaryKey: 'id',
+ *   indexes: ['email', 'role']
+ * })
+ *
+ * // CRUD Operations
+ * const user = await users.insert({
+ *   id: '1',
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   role: 'admin'
+ * })
+ *
+ * const updated = await users.update(
+ *   { id: '1' },
+ *   { name: 'Alicia' }
+ * )
+ *
+ * const found = await users.findOne({ id: '1' })
+ *
+ * const admins = await users.findMany({
+ *   where: { role: 'admin' },
+ *   orderBy: { name: 'asc' }
+ * })
+ *
+ * await users.delete({ id: '1' })
+ *
+ * // Subscribe to changes
+ * const unsubscribe = users.subscribe((allUsers) => {
+ *   console.log('Users updated:', allUsers)
+ * })
+ * ```
+ */
+declare function createCollection<T extends Record<string, any>>(config: CreateCollectionConfig<T>): Collection<T>;
+
+/**
+ * @mdxui/terminal DO Sync Adapter
+ *
+ * Durable Objects sync adapter for bidirectional data synchronization
+ * via WebSocket connection. Provides:
+ * - WebSocket connection lifecycle management
+ * - Bidirectional data synchronization
+ * - Auth header injection for authenticated requests
+ * - Optimistic updates with server confirmation
+ * - Automatic reconnection with exponential backoff + jitter
+ * - Offline mutation queue for resilience
+ * - Connection state observable
+ * - Error categorization (recoverable vs fatal)
+ *
+ * @remarks
+ * ## Connection State Machine
+ *
+ * ```
+ * ┌─────────────┐   connect()   ┌────────────┐
+ * │ disconnected│──────────────►│ connecting │
+ * └─────────────┘               └────────────┘
+ *       ▲                             │
+ *       │                             │ onopen
+ *       │ close()                     ▼
+ *       │                       ┌───────────┐
+ *       │◄──────────────────────│ connected │
+ *       │  close() / fatal err  └───────────┘
+ *       │                             │
+ *       │                             │ recoverable error / close
+ *       │                             ▼
+ *       │                      ┌─────────────┐
+ *       │◄─────────────────────│ reconnecting│───► (loop with backoff)
+ *       │  max attempts        └─────────────┘
+ * ```
+ *
+ * ## Error Categories
+ *
+ * **Recoverable errors** - trigger reconnection:
+ * - Network timeouts
+ * - Temporary server unavailability
+ * - WebSocket close codes 1001 (going away), 1006 (abnormal closure)
+ *
+ * **Fatal errors** - require user intervention:
+ * - Authentication failures (401, 403)
+ * - Invalid namespace URL
+ * - WebSocket close code 1008 (policy violation)
+ * - Close code 4000+ (application-level errors)
+ *
+ * @module
+ */
+
+/**
+ * Connection state for monitoring adapter health.
+ *
+ * State transitions follow a deterministic state machine pattern:
+ *
+ * @remarks
+ * - `disconnected`: No active WebSocket connection. Initial state and terminal state.
+ * - `connecting`: WebSocket connection in progress. Transitions to `connected` on success,
+ *   `disconnected` on fatal error, or `reconnecting` on recoverable error (if enabled).
+ * - `connected`: Active WebSocket connection ready for sync. Can transition to
+ *   `disconnected` on close/fatal error or `reconnecting` on recoverable error.
+ * - `reconnecting`: Attempting to re-establish connection after a recoverable failure.
+ *   Includes exponential backoff with jitter. Transitions to `connecting` when attempting,
+ *   `disconnected` when max attempts reached or user calls close().
+ *
+ * @example
+ * ```typescript
+ * const sync = createDOSync({ namespaceUrl: '...' })
+ *
+ * sync.onConnectionStateChange((state) => {
+ *   switch (state) {
+ *     case 'disconnected':
+ *       showOfflineIndicator()
+ *       break
+ *     case 'connecting':
+ *     case 'reconnecting':
+ *       showConnectingSpinner()
+ *       break
+ *     case 'connected':
+ *       hideOfflineIndicator()
+ *       break
+ *   }
+ * })
+ * ```
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * Queued mutation for offline resilience.
+ *
+ * @remarks
+ * When the adapter is offline, mutations are queued and automatically
+ * retried once the connection is re-established. This ensures no data
+ * is lost during temporary disconnections.
+ *
+ * ## Lifecycle
+ * 1. Push fails due to connection error
+ * 2. Mutation is added to queue with timestamp
+ * 3. Connection is restored
+ * 4. Queue is flushed in FIFO order
+ * 5. Successful mutations are removed from queue
+ * 6. Failed mutations remain with incremented retryCount
+ *
+ * ## Inspection
+ * Use `getQueuedMutations()` to inspect the queue for debugging
+ * or displaying pending sync status to users.
+ *
+ * @example
+ * ```typescript
+ * // Display pending changes to user
+ * const pending = adapter.getQueuedMutations()
+ * if (pending.length > 0) {
+ *   console.log(`${pending.length} changes waiting to sync`)
+ * }
+ * ```
+ */
+interface QueuedMutation {
+    /** Unique identifier for this mutation (auto-generated) */
+    id: string;
+    /** The changes to sync to the server */
+    changes: unknown[];
+    /** Timestamp (ms since epoch) when mutation was queued */
+    queuedAt: number;
+    /** Number of failed retry attempts (0 = first attempt pending) */
+    retryCount: number;
+}
+/**
+ * Reconnection configuration options.
+ *
+ * @remarks
+ * Configures automatic reconnection behavior with exponential backoff.
+ * When enabled, the adapter will automatically attempt to reconnect
+ * on connection loss until maxAttempts is reached.
+ *
+ * ## Defaults
+ * - `enabled`: false (opt-in for auto-reconnect)
+ * - `maxAttempts`: Infinity (keep trying forever)
+ * - `initialDelay`: 1000ms (1 second)
+ * - `maxDelay`: 30000ms (30 seconds cap)
+ *
+ * ## Backoff Formula
+ * `delay = min(initialDelay * 2^attempt, maxDelay)`
+ *
+ * @example
+ * ```typescript
+ * // Recommended production config
+ * const sync = createDOSync({
+ *   namespaceUrl: '...',
+ *   reconnect: {
+ *     enabled: true,
+ *     maxAttempts: 10,
+ *     initialDelay: 1000,
+ *     maxDelay: 30000
+ *   }
+ * })
+ * ```
+ */
+interface ReconnectOptions {
+    /**
+     * Whether to automatically reconnect on connection loss.
+     * @defaultValue false
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of reconnection attempts before giving up.
+     * Set to Infinity to retry indefinitely.
+     * @defaultValue Infinity
+     */
+    maxAttempts?: number;
+    /**
+     * Initial delay in ms before first reconnection attempt.
+     * Subsequent delays are calculated with exponential backoff.
+     * @defaultValue 1000
+     */
+    initialDelay?: number;
+    /**
+     * Maximum delay in ms between reconnection attempts (backoff cap).
+     * @defaultValue 30000
+     */
+    maxDelay?: number;
+}
+/**
+ * Conflict resolution strategy for handling server-client data conflicts.
+ *
+ * @remarks
+ * - `server-wins`: Server version is authoritative, client changes discarded
+ * - `client-wins`: Client version is authoritative, server changes overwritten
+ * - `merge`: Attempt to merge both versions (server determines merge logic)
+ * - `throw`: Reject push with conflict error, let caller handle
+ * - `custom`: Call `onConflict` callback for custom resolution logic
+ */
+type ConflictResolution = 'server-wins' | 'client-wins' | 'merge' | 'throw' | 'custom';
+/**
+ * Conflict details returned by server when client/server versions diverge.
+ */
+interface Conflict {
+    /** ID of the conflicting entity */
+    id: string;
+    /** Server's current version of the entity */
+    serverVersion: Record<string, unknown>;
+}
+/**
+ * Configuration for creating a DO Sync adapter.
+ *
+ * @remarks
+ * ## Minimal Configuration
+ * ```typescript
+ * const sync = createDOSync({
+ *   namespaceUrl: 'https://api.example.com/namespace'
+ * })
+ * ```
+ *
+ * ## Full Configuration
+ * ```typescript
+ * const sync = createDOSync({
+ *   namespaceUrl: 'https://api.example.com/namespace',
+ *   authToken: 'jwt-token',
+ *   reconnect: { enabled: true, maxAttempts: 10 },
+ *   conflictResolution: 'server-wins',
+ *   requestTimeout: 10000
+ * })
+ * ```
+ */
+interface DOSyncConfig {
+    /**
+     * URL of the Durable Objects namespace endpoint.
+     * Will be converted to WebSocket URL (https -> wss, http -> ws).
+     *
+     * @example 'https://api.example.com/namespace'
+     */
+    namespaceUrl: string;
+    /**
+     * Optional auth token for authenticated connections.
+     * Sent as URL query param and in message payloads.
+     * Can be updated dynamically via `setAuthToken()`.
+     */
+    authToken?: string;
+    /**
+     * Automatic reconnection options.
+     * @see ReconnectOptions for defaults and configuration
+     */
+    reconnect?: ReconnectOptions;
+    /**
+     * Strategy for resolving server-client data conflicts.
+     * @defaultValue 'server-wins' (implicit - server decides)
+     */
+    conflictResolution?: ConflictResolution;
+    /**
+     * Custom conflict resolver callback.
+     * Required when `conflictResolution` is 'custom'.
+     *
+     * @param conflicts - Array of conflicting entities with server versions
+     * @returns Promise resolving to `{ resolved: true }` when conflicts handled
+     */
+    onConflict?: (conflicts: Conflict[]) => Promise<{
+        resolved: boolean;
+    }>;
+    /**
+     * Request timeout in milliseconds for push/pull operations.
+     * Operations will reject with timeout error if no response received.
+     * @defaultValue 30000 (30 seconds)
+     */
+    requestTimeout?: number;
+}
+/**
+ * Connection state observer callback type.
+ *
+ * @remarks
+ * Called whenever the connection state changes. Useful for UI feedback
+ * (e.g., showing "offline" status, disabling sync buttons, etc.).
+ *
+ * @param state - The new connection state
+ */
+type ConnectionStateObserver = (state: ConnectionState) => void;
+/**
+ * Extended sync adapter with connection management and state monitoring.
+ *
+ * @remarks
+ * Extends the base SyncAdapter with:
+ * - Connection lifecycle management (`close()`)
+ * - Dynamic auth token updates (`setAuthToken()`)
+ * - Reactive connection state (`onConnectionStateChange()`, `getConnectionState()`)
+ * - Offline queue inspection (`getQueuedMutations()`, `getQueueStats()`)
+ *
+ * ## Offline Resilience
+ * When push operations fail due to connection errors, mutations are
+ * automatically queued and retried when the connection is restored.
+ * This ensures no data is lost during temporary disconnections.
+ *
+ * @example
+ * ```typescript
+ * const sync = createDOSync({ namespaceUrl: '...' })
+ *
+ * // React to connection state changes
+ * sync.onConnectionStateChange((state) => {
+ *   updateStatusIndicator(state)
+ * })
+ *
+ * // Check pending changes
+ * const { count, oldestAt } = sync.getQueueStats()
+ * if (count > 0) {
+ *   showPendingBanner(`${count} changes pending since ${new Date(oldestAt!)}`)
+ * }
+ *
+ * // Cleanup on unmount
+ * sync.close()
+ * ```
+ */
+interface DOSyncAdapter extends SyncAdapter {
+    /**
+     * Close the WebSocket connection and stop all reconnection attempts.
+     * Call this when unmounting or navigating away to clean up resources.
+     */
+    close(): void;
+    /**
+     * Update the auth token dynamically.
+     * Useful for refreshing expired tokens without recreating the adapter.
+     * The new token will be used for subsequent connections.
+     *
+     * @param token - New auth token
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Subscribe to connection state changes.
+     * Callback is called immediately with current state, then on each change.
+     *
+     * @param callback - Observer function called on state changes
+     * @returns Unsubscribe function
+     */
+    onConnectionStateChange(callback: ConnectionStateObserver): () => void;
+    /**
+     * Get current connection state without subscribing.
+     * Use for one-time checks; use `onConnectionStateChange()` for reactive updates.
+     *
+     * @returns Current connection state
+     */
+    getConnectionState(): ConnectionState;
+    /**
+     * Get all mutations currently in the offline queue.
+     * Useful for debugging or displaying pending sync status.
+     *
+     * @returns Array of queued mutations
+     */
+    getQueuedMutations(): QueuedMutation[];
+    /**
+     * Get summary statistics about the offline queue.
+     *
+     * @returns Object with:
+     *   - `count`: Number of pending mutations
+     *   - `oldestAt`: Timestamp of oldest mutation (null if empty)
+     */
+    getQueueStats(): {
+        count: number;
+        oldestAt: number | null;
+    };
+}
+/**
+ * Create a Durable Objects sync adapter
+ *
+ * @param config - Configuration options
+ * @returns A sync adapter instance for use with createDB
+ *
+ * @throws Error if namespaceUrl is empty or invalid
+ *
+ * @example
+ * ```typescript
+ * import { createDOSync } from '@mdxui/terminal'
+ *
+ * const sync = createDOSync({
+ *   namespaceUrl: 'https://api.example.com/namespace',
+ *   authToken: 'your-auth-token',
+ *   reconnect: { enabled: true, maxAttempts: 5 }
+ * })
+ *
+ * const db = createDB({
+ *   collections: [usersCollection],
+ *   sync
+ * })
+ * ```
+ */
+declare function createDOSync(config: DOSyncConfig): DOSyncAdapter;
+
+/**
+ * @mdxui/terminal Database Context
+ *
+ * React Context API provider for database access throughout component tree.
+ * Enables hooks like `useQuery` and `useMutation` to access the database
+ * without prop drilling.
+ */
+
+/**
+ * Props for DBProvider component
+ *
+ * @example
+ * ```typescript
+ * const props: DBProviderProps = {
+ *   db: myDatabase,
+ *   children: <App />
+ * }
+ * ```
+ */
+interface DBProviderProps {
+    /** Database instance to provide to all children */
+    db: DB;
+    /** React components that will have access to the database */
+    children: ReactNode;
+}
+/**
+ * Database provider component - wraps your app to provide database context
+ *
+ * Provides database access to all child components via React Context.
+ * Must wrap any component using `useQuery` or `useMutation` hooks.
+ *
+ * @remarks
+ * - Use at the top level of your app (e.g., around `<App />`)
+ * - Can have multiple DBProviders with different database instances
+ * - All useQuery and useMutation hooks must be within a DBProvider
+ * - Throws error if hooks are used outside DBProvider
+ *
+ * @example
+ * ```tsx
+ * import { z } from 'zod'
+ * import { createDB, createCollection, DBProvider } from '@mdxui/terminal'
+ *
+ * // Create database
+ * const db = createDB({
+ *   collections: [usersCollection, todosCollection]
+ * })
+ *
+ * // Wrap app with provider
+ * export function App() {
+ *   return (
+ *     <DBProvider db={db}>
+ *       <UserList />
+ *       <TodoForm />
+ *     </DBProvider>
+ *   )
+ * }
+ *
+ * // Now these hooks work:
+ * function UserList() {
+ *   const { data, isLoading } = useQuery({
+ *     from: 'users',
+ *     where: { role: 'admin' }
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return (
+ *     <ul>
+ *       {data?.map(user => (
+ *         <li key={user.id}>{user.name}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ *
+ * function TodoForm() {
+ *   const { mutate, isPending } = useMutation({
+ *     collection: 'todos',
+ *     operation: 'insert'
+ *   })
+ *
+ *   return (
+ *     <form onSubmit={(e) => {
+ *       e.preventDefault()
+ *       mutate({ id: '1', title: 'New', completed: false })
+ *     }}>
+ *       <button disabled={isPending}>Add Todo</button>
+ *     </form>
+ *   )
+ * }
+ * ```
+ */
+declare function DBProvider({ db, children }: DBProviderProps): React.ReactElement;
+/**
+ * Hook to access the database instance from context
+ *
+ * @returns The database instance from the nearest DBProvider
+ * @throws Error if used outside a DBProvider component
+ *
+ * @remarks
+ * - Must be called within a component tree wrapped by DBProvider
+ * - Allows direct access to collections (advanced use case)
+ * - Most apps use useQuery/useMutation instead
+ * - Useful for manual collection operations outside hooks
+ *
+ * @example
+ * ```tsx
+ * // Direct database access (advanced)
+ * function MyComponent() {
+ *   const db = useDBContext()
+ *
+ *   // Manually query
+ *   const handleClick = async () => {
+ *     const admins = await db.collections.users.findMany({
+ *       where: { role: 'admin' }
+ *     })
+ *     console.log('Admins:', admins)
+ *   }
+ *
+ *   return <button onClick={handleClick}>Get Admins</button>
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Subscribe to collection changes (advanced)
+ * function CollectionMonitor() {
+ *   const db = useDBContext()
+ *
+ *   React.useEffect(() => {
+ *     const unsubscribe = db.collections.users.subscribe((users) => {
+ *       console.log('Users changed:', users)
+ *     })
+ *     return unsubscribe
+ *   }, [db])
+ *
+ *   return <div>Monitoring changes...</div>
+ * }
+ * ```
+ */
+declare function useDBContext(): DB;
+
+/**
+ * @mdxui/terminal Data Hooks
+ *
+ * React hooks for reactive queries and mutations with optimistic updates.
+ * Provides type-safe hooks for querying and mutating database collections
+ * within a DBProvider context.
+ */
+
+/**
+ * React hook for reactive data queries with filtering, sorting, and pagination
+ *
+ * @template T - The document type being queried
+ *
+ * @param options - Query options (collection name, filters, sorting, pagination)
+ * @returns Query result with reactive data, loading/error states, and refetch control
+ *
+ * @remarks
+ * - Must be used within a DBProvider component
+ * - Automatically fetches initial data on mount
+ * - Reactively updates when collection changes (subscriptions)
+ * - Filters, sorting, and pagination are re-applied when data changes
+ * - `data` is undefined while loading, array when loaded
+ * - `isLoading` is true for the initial fetch only
+ * - Manual refetch available via `refetch()` function
+ * - Error state persists until query succeeds
+ *
+ * @example
+ * ```tsx
+ * // Basic query - get all documents
+ * function AllUsers() {
+ *   const { data, isLoading, error } = useQuery({
+ *     from: 'users'
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   if (error) return <div>Error: {error.message}</div>
+ *
+ *   return (
+ *     <ul>
+ *       {data?.map(user => (
+ *         <li key={user.id}>{user.name}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With filtering
+ * function AdminUsers() {
+ *   const { data } = useQuery({
+ *     from: 'users',
+ *     where: { role: 'admin' }
+ *   })
+ *
+ *   return data?.map(user => <AdminCard key={user.id} user={user} />)
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With sorting and pagination
+ * function UsersPaginated() {
+ *   const { data, refetch } = useQuery({
+ *     from: 'users',
+ *     where: { status: 'active' },
+ *     orderBy: { createdAt: 'desc' },
+ *     limit: 20,
+ *     offset: 0
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <Users data={data} />
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With comparison operators
+ * function AdultUsers() {
+ *   const { data } = useQuery({
+ *     from: 'users',
+ *     where: { age: { $gte: 18 } }
+ *   })
+ *
+ *   return data?.map(user => <Card key={user.id} user={user} />)
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With OR conditions
+ * function AdminsOrModerators() {
+ *   const { data } = useQuery({
+ *     from: 'users',
+ *     where: {
+ *       $or: [
+ *         { role: 'admin' },
+ *         { role: 'moderator' }
+ *       ]
+ *     }
+ *   })
+ *
+ *   return data?.map(user => <Card key={user.id} user={user} />)
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With multiple sort fields
+ * function UsersSorted() {
+ *   const { data } = useQuery({
+ *     from: 'users',
+ *     orderBy: [
+ *       { role: 'asc' },
+ *       { name: 'asc' }
+ *     ]
+ *   })
+ *
+ *   return data?.map(user => <Card key={user.id} user={user} />)
+ * }
+ * ```
+ */
+declare function useQuery<T extends Record<string, any>>(options: QueryOptions<T>): QueryResult<T>;
+/**
+ * React hook for data mutations (insert, update, delete) with optimistic updates
+ *
+ * @template T - The document type being mutated
+ *
+ * @param options - Mutation options (collection, operation, optimistic mode)
+ * @returns Mutation result with mutate function, pending/error states, and reset
+ *
+ * @remarks
+ * - Must be used within a DBProvider component
+ * - Supports three operations: insert, update, delete
+ * - Optimistic updates: UI updates immediately, rolls back on error
+ * - Manual updates: UI updates only after server confirmation
+ * - `isPending` is true while mutation is executing
+ * - Error state persists until mutation succeeds or `reset()` is called
+ * - Data format depends on operation type:
+ *   - `insert`: T (full document)
+ *   - `update`: UpdateMutationData<T> (where + data)
+ *   - `delete`: DeleteMutationData<T> (id)
+ * - Sync adapter is called when optimistic=true and sync is configured
+ *
+ * @example
+ * ```tsx
+ * // Insert with optimistic update
+ * function CreateUserForm() {
+ *   const { mutate, isPending, error, reset } = useMutation({
+ *     collection: 'users',
+ *     operation: 'insert',
+ *     optimistic: true
+ *   })
+ *
+ *   const handleSubmit = async (formData) => {
+ *     try {
+ *       await mutate({
+ *         id: crypto.randomUUID(),
+ *         name: formData.name,
+ *         email: formData.email,
+ *         role: 'user'
+ *       })
+ *       console.log('User created!')
+ *     } catch (err) {
+ *       console.error('Failed to create user')
+ *     }
+ *   }
+ *
+ *   return (
+ *     <form onSubmit={async (e) => {
+ *       e.preventDefault()
+ *       await handleSubmit(Object.fromEntries(new FormData(e.currentTarget)))
+ *     }}>
+ *       <input name="name" required />
+ *       <input name="email" type="email" required />
+ *       <button disabled={isPending}>
+ *         {isPending ? 'Creating...' : 'Create'}
+ *       </button>
+ *       {error && (
+ *         <div>
+ *           <p>Error: {error.message}</p>
+ *           <button onClick={reset}>Dismiss</button>
+ *         </div>
+ *       )}
+ *     </form>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Update mutation
+ * function EditUserForm({ userId }) {
+ *   const { mutate, isPending } = useMutation({
+ *     collection: 'users',
+ *     operation: 'update'
+ *   })
+ *
+ *   const handleSave = async (updates) => {
+ *     await mutate({
+ *       where: { id: userId },
+ *       data: updates
+ *     })
+ *   }
+ *
+ *   return <Form onSave={handleSave} disabled={isPending} />
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Delete mutation
+ * function DeleteUserButton({ userId }) {
+ *   const { mutate, isPending } = useMutation({
+ *     collection: 'users',
+ *     operation: 'delete'
+ *   })
+ *
+ *   const handleDelete = async () => {
+ *     if (confirm('Really delete?')) {
+ *       await mutate({ id: userId })
+ *     }
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleDelete} disabled={isPending}>
+ *       {isPending ? 'Deleting...' : 'Delete'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Optimistic vs non-optimistic
+ * function UserActions() {
+ *   // UI updates immediately, auto-rollback on error
+ *   const { mutate: optimisticInsert } = useMutation({
+ *     collection: 'users',
+ *     operation: 'insert',
+ *     optimistic: true  // Default UI update
+ *   })
+ *
+ *   // UI updates only after server confirms
+ *   const { mutate: carefullInsert } = useMutation({
+ *     collection: 'users',
+ *     operation: 'insert',
+ *     optimistic: false  // Wait for server
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => optimisticInsert(newUser)}>
+ *         Quick Add (optimistic)
+ *       </button>
+ *       <button onClick={() => carefullInsert(newUser)}>
+ *         Safe Add (wait for server)
+ *       </button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useMutation<T extends Record<string, any>>(options: MutationOptions): MutationResult<T>;
+
+/**
+ * @mdxui/terminal Reactive Data Hooks for Data Components
+ *
+ * This module provides React hooks for connecting data components (Table, List,
+ * Card, Metrics) to TanStack DB collections with reactive updates and optimistic
+ * mutations.
+ *
+ * Key features:
+ * - Reactive data binding - UI updates automatically when collection data changes
+ * - Optimistic updates - UI updates immediately, rolls back on error
+ * - Type-safe queries - Full TypeScript support with Zod validation
+ * - Live subscriptions - Real-time updates from collection changes
+ *
+ * @example
+ * ```tsx
+ * import { useReactiveTable, useReactiveList } from '@mdxui/terminal'
+ *
+ * function UsersTable() {
+ *   const { data, isLoading, mutate, sort, setSort } = useReactiveTable({
+ *     collection: 'users',
+ *     where: { status: 'active' },
+ *     orderBy: { name: 'asc' },
+ *   })
+ *
+ *   // Data updates reactively when collection changes
+ *   return (
+ *     <Table
+ *       columns={[
+ *         { key: 'name', header: 'Name', sortable: true },
+ *         { key: 'email', header: 'Email' },
+ *       ]}
+ *       data={data}
+ *       sortBy={sort.field}
+ *       sortDirection={sort.direction}
+ *       onSort={(field) => setSort(field)}
+ *       onRowAction={(action, row) => {
+ *         if (action === 'delete') {
+ *           mutate.delete({ id: row.id })
+ *         }
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+
+/**
+ * Sort state for reactive data components
+ *
+ * @example
+ * ```typescript
+ * const sort: SortState = {
+ *   field: 'createdAt',
+ *   direction: 'desc',
+ * }
+ * ```
+ */
+interface SortState {
+    /** Field to sort by */
+    field: string | null;
+    /** Sort direction: 'asc' or 'desc' */
+    direction: OrderDirection;
+}
+/**
+ * Selection state for reactive data components
+ *
+ * @example
+ * ```typescript
+ * const selection: SelectionState = {
+ *   mode: 'multi',
+ *   selected: new Set(['user-1', 'user-3']),
+ * }
+ * ```
+ */
+interface SelectionState {
+    /** Selection mode: 'single', 'multi', or 'none' */
+    mode: 'single' | 'multi' | 'none';
+    /** Set of selected item IDs */
+    selected: Set<string>;
+}
+/**
+ * Pagination state for reactive data components
+ *
+ * @example
+ * ```typescript
+ * const pagination: PaginationState = {
+ *   page: 1,
+ *   pageSize: 20,
+ *   total: 150,
+ * }
+ * ```
+ */
+interface PaginationState {
+    /** Current page (1-indexed) */
+    page: number;
+    /** Items per page */
+    pageSize: number;
+    /** Total item count (from query) */
+    total: number;
+}
+/**
+ * Options for useReactiveData hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Extends QueryOptions with reactive-specific options like selection, sorting,
+ * and pagination control.
+ *
+ * @example
+ * ```typescript
+ * const options: ReactiveDataOptions<User> = {
+ *   collection: 'users',
+ *   where: { role: 'admin' },
+ *   orderBy: { createdAt: 'desc' },
+ *   limit: 20,
+ *   selectable: 'multi',
+ *   optimistic: true,
+ * }
+ * ```
+ */
+interface ReactiveDataOptions<T> {
+    /** Collection name to query from */
+    collection: string;
+    /** Filter conditions */
+    where?: WhereClause<T>;
+    /** Sort order */
+    orderBy?: OrderByClause<T> | OrderByClause<T>[];
+    /** Maximum items to return */
+    limit?: number;
+    /** Items to skip (for pagination) */
+    offset?: number;
+    /** Enable selection: 'single', 'multi', or false */
+    selectable?: 'single' | 'multi' | boolean;
+    /** Enable optimistic updates (default: true) */
+    optimistic?: boolean;
+    /** Primary key field (default: 'id') */
+    primaryKey?: keyof T;
+}
+/**
+ * Result of useReactiveData hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Provides reactive data, loading/error states, mutation functions, and
+ * controls for sorting, selection, and pagination.
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   data,
+ *   isLoading,
+ *   error,
+ *   mutate,
+ *   sort,
+ *   setSort,
+ *   selection,
+ *   toggleSelect,
+ *   pagination,
+ *   setPage,
+ * } = useReactiveData<User>({ collection: 'users' })
+ * ```
+ */
+interface ReactiveDataResult<T> {
+    /** Reactive data array - updates when collection changes */
+    data: T[];
+    /** True while initial query is executing */
+    isLoading: boolean;
+    /** Error if query or mutation failed */
+    error: Error | undefined;
+    /** Manual refetch function */
+    refetch: () => void;
+    /** Mutation functions for insert, update, delete */
+    mutate: {
+        /** Insert a new document */
+        insert: (data: T) => Promise<void>;
+        /** Update documents matching filter */
+        update: (filter: Partial<T>, updates: Partial<T>) => Promise<void>;
+        /** Delete a document by ID */
+        delete: (filter: {
+            id: string;
+        } | Partial<T>) => Promise<void>;
+    };
+    /** True while any mutation is pending */
+    isMutating: boolean;
+    /** Current sort state */
+    sort: SortState;
+    /** Set sort field (toggles direction if same field) */
+    setSort: (field: string) => void;
+    /** Current selection state */
+    selection: SelectionState;
+    /** Toggle selection for an item */
+    toggleSelect: (id: string) => void;
+    /** Select all items */
+    selectAll: () => void;
+    /** Clear all selections */
+    clearSelection: () => void;
+    /** Current pagination state */
+    pagination: PaginationState;
+    /** Go to a specific page */
+    setPage: (page: number) => void;
+    /** Change page size */
+    setPageSize: (size: number) => void;
+}
+/**
+ * Options for useReactiveTable hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Table-specific options extending ReactiveDataOptions with column definitions.
+ */
+interface ReactiveTableOptions<T> extends ReactiveDataOptions<T> {
+    /** Column definitions for the table */
+    columns?: Array<{
+        key: keyof T;
+        header: string;
+        sortable?: boolean;
+        width?: number;
+        align?: 'left' | 'center' | 'right';
+    }>;
+}
+/**
+ * Options for useReactiveList hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * List-specific options extending ReactiveDataOptions.
+ */
+interface ReactiveListOptions<T> extends ReactiveDataOptions<T> {
+    /** Field to use as display text */
+    labelField?: keyof T;
+    /** Field to use as icon */
+    iconField?: keyof T;
+}
+/**
+ * Options for useReactiveMetrics hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Metrics-specific options for aggregated data display.
+ */
+interface ReactiveMetricsOptions<T> extends Omit<ReactiveDataOptions<T>, 'limit' | 'offset'> {
+    /** Metrics to compute from collection data */
+    metrics: Array<{
+        /** Unique key for the metric */
+        key: string;
+        /** Display label */
+        label: string;
+        /** Field to aggregate */
+        field: keyof T;
+        /** Aggregation function */
+        aggregate: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'latest';
+        /** Format for display */
+        format?: 'number' | 'currency' | 'percentage';
+        /** Unit suffix */
+        unit?: string;
+    }>;
+}
+/**
+ * Single metric result
+ */
+interface MetricValue {
+    /** Metric key */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Computed value */
+    value: number | string;
+    /** Trend direction (computed from previous values if available) */
+    trend?: 'up' | 'down' | 'neutral';
+    /** Trend percentage change */
+    trendValue?: number;
+    /** Optional sparkline data */
+    sparkline?: number[];
+}
+/**
+ * Result of useReactiveMetrics hook
+ */
+interface ReactiveMetricsResult {
+    /** Computed metric values */
+    metrics: MetricValue[];
+    /** True while initial query is executing */
+    isLoading: boolean;
+    /** Error if query failed */
+    error: Error | undefined;
+    /** Manual refetch function */
+    refetch: () => void;
+}
+/**
+ * Options for useReactiveCard hook
+ *
+ * @template T - The document type
+ *
+ * @remarks
+ * Card-specific options for single-record display.
+ */
+interface ReactiveCardOptions<T> {
+    /** Collection name */
+    collection: string;
+    /** Filter to find single record */
+    where: WhereClause<T>;
+    /** Fields to display as key-value pairs */
+    fields?: Array<{
+        key: keyof T;
+        label: string;
+        format?: 'string' | 'date' | 'currency' | 'badge';
+    }>;
+    /** Enable optimistic updates */
+    optimistic?: boolean;
+}
+/**
+ * Result of useReactiveCard hook
+ */
+interface ReactiveCardResult<T> {
+    /** Single record data */
+    data: T | null;
+    /** True while loading */
+    isLoading: boolean;
+    /** Error if query failed */
+    error: Error | undefined;
+    /** Refetch function */
+    refetch: () => void;
+    /** Update the record */
+    update: (updates: Partial<T>) => Promise<void>;
+    /** True while updating */
+    isUpdating: boolean;
+}
+/**
+ * Hook for reactive data binding with TanStack DB collections
+ *
+ * Provides reactive data updates, optimistic mutations, sorting, selection,
+ * and pagination for data components like Table and List.
+ *
+ * @template T - The document type (must extend Record<string, any>)
+ *
+ * @param options - Configuration for collection, filters, and behavior
+ * @returns ReactiveDataResult with data, mutations, and state controls
+ *
+ * @remarks
+ * - Data updates automatically when collection changes (via subscriptions)
+ * - Optimistic updates show changes immediately, roll back on error
+ * - Sort state toggles direction when same field is selected
+ * - Selection supports single and multi-select modes
+ * - Pagination is handled client-side with limit/offset
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const {
+ *     data,
+ *     isLoading,
+ *     mutate,
+ *     sort,
+ *     setSort,
+ *     selection,
+ *     toggleSelect,
+ *   } = useReactiveData<User>({
+ *     collection: 'users',
+ *     where: { status: 'active' },
+ *     orderBy: { name: 'asc' },
+ *     selectable: 'multi',
+ *   })
+ *
+ *   if (isLoading) return <Spinner />
+ *
+ *   return (
+ *     <List
+ *       items={data.map(user => ({
+ *         id: user.id,
+ *         text: user.name,
+ *         selected: selection.selected.has(user.id),
+ *       }))}
+ *       onItemClick={(id) => toggleSelect(id)}
+ *       onDelete={(id) => mutate.delete({ id })}
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With optimistic updates
+ * function QuickAddUser() {
+ *   const { mutate, isMutating } = useReactiveData<User>({
+ *     collection: 'users',
+ *     optimistic: true,
+ *   })
+ *
+ *   const handleAdd = async () => {
+ *     // UI updates immediately, rolls back if server fails
+ *     await mutate.insert({
+ *       id: crypto.randomUUID(),
+ *       name: 'New User',
+ *       status: 'active',
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleAdd} disabled={isMutating}>
+ *       {isMutating ? 'Adding...' : 'Add User'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useReactiveData<T extends Record<string, any>>(options: ReactiveDataOptions<T>): ReactiveDataResult<T>;
+/**
+ * Hook for reactive table data with TanStack DB integration
+ *
+ * Specialized version of useReactiveData for Table components with
+ * column-aware sorting and selection.
+ *
+ * @template T - The document type
+ *
+ * @param options - Table-specific options including column definitions
+ * @returns ReactiveDataResult with table-optimized behavior
+ *
+ * @example
+ * ```tsx
+ * function UsersTable() {
+ *   const {
+ *     data,
+ *     sort,
+ *     setSort,
+ *     selection,
+ *     toggleSelect,
+ *   } = useReactiveTable<User>({
+ *     collection: 'users',
+ *     columns: [
+ *       { key: 'name', header: 'Name', sortable: true },
+ *       { key: 'email', header: 'Email' },
+ *       { key: 'role', header: 'Role', sortable: true },
+ *     ],
+ *     selectable: 'multi',
+ *   })
+ *
+ *   return (
+ *     <Table
+ *       columns={columns}
+ *       data={data}
+ *       sortBy={sort.field}
+ *       sortDirection={sort.direction}
+ *       onSort={setSort}
+ *       selectedRows={Array.from(selection.selected)}
+ *       onRowSelect={toggleSelect}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function useReactiveTable<T extends Record<string, any>>(options: ReactiveTableOptions<T>): ReactiveDataResult<T>;
+/**
+ * Hook for reactive list data with TanStack DB integration
+ *
+ * Specialized version of useReactiveData for List components with
+ * item-level selection and actions.
+ *
+ * @template T - The document type
+ *
+ * @param options - List-specific options
+ * @returns ReactiveDataResult with list-optimized behavior
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const {
+ *     data,
+ *     mutate,
+ *     toggleSelect,
+ *   } = useReactiveList<Task>({
+ *     collection: 'tasks',
+ *     where: { completed: false },
+ *     orderBy: { priority: 'desc' },
+ *     labelField: 'title',
+ *     selectable: 'single',
+ *   })
+ *
+ *   return (
+ *     <List
+ *       items={data.map(task => ({
+ *         id: task.id,
+ *         content: task.title,
+ *         icon: task.priority === 'high' ? 'alert' : 'task',
+ *       }))}
+ *       onItemClick={(id) => toggleSelect(id)}
+ *       onDelete={(id) => mutate.delete({ id })}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function useReactiveList<T extends Record<string, any>>(options: ReactiveListOptions<T>): ReactiveDataResult<T>;
+/**
+ * Hook for reactive metrics computed from TanStack DB collections
+ *
+ * Aggregates collection data into metric values with optional trend
+ * computation and sparkline data.
+ *
+ * @template T - The document type
+ *
+ * @param options - Metrics configuration with aggregation definitions
+ * @returns ReactiveMetricsResult with computed metric values
+ *
+ * @example
+ * ```tsx
+ * function DashboardMetrics() {
+ *   const { metrics, isLoading } = useReactiveMetrics<Order>({
+ *     collection: 'orders',
+ *     where: { status: 'completed' },
+ *     metrics: [
+ *       {
+ *         key: 'total-orders',
+ *         label: 'Total Orders',
+ *         field: 'id',
+ *         aggregate: 'count',
+ *       },
+ *       {
+ *         key: 'revenue',
+ *         label: 'Revenue',
+ *         field: 'total',
+ *         aggregate: 'sum',
+ *         format: 'currency',
+ *       },
+ *       {
+ *         key: 'avg-order',
+ *         label: 'Avg Order',
+ *         field: 'total',
+ *         aggregate: 'avg',
+ *         format: 'currency',
+ *       },
+ *     ],
+ *   })
+ *
+ *   if (isLoading) return <Spinner />
+ *
+ *   return (
+ *     <Metrics
+ *       metrics={metrics.map(m => ({
+ *         label: m.label,
+ *         value: m.value,
+ *         trend: m.trend,
+ *         trendValue: m.trendValue,
+ *       }))}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function useReactiveMetrics<T extends Record<string, any>>(options: ReactiveMetricsOptions<T>): ReactiveMetricsResult;
+/**
+ * Hook for reactive single-record card data with TanStack DB integration
+ *
+ * Fetches and subscribes to a single record from a collection for
+ * Card component display.
+ *
+ * @template T - The document type
+ *
+ * @param options - Card-specific options
+ * @returns ReactiveCardResult with single record and update function
+ *
+ * @example
+ * ```tsx
+ * function UserProfileCard({ userId }: { userId: string }) {
+ *   const {
+ *     data,
+ *     isLoading,
+ *     update,
+ *     isUpdating,
+ *   } = useReactiveCard<User>({
+ *     collection: 'users',
+ *     where: { id: userId },
+ *     fields: [
+ *       { key: 'name', label: 'Name' },
+ *       { key: 'email', label: 'Email' },
+ *       { key: 'role', label: 'Role', format: 'badge' },
+ *     ],
+ *   })
+ *
+ *   if (isLoading) return <Spinner />
+ *   if (!data) return <Empty message="User not found" />
+ *
+ *   return (
+ *     <Card
+ *       title={data.name}
+ *       subtitle={data.email}
+ *       pairs={[
+ *         { key: 'Role', value: data.role },
+ *         { key: 'Status', value: data.status },
+ *       ]}
+ *       actions={[
+ *         {
+ *           label: isUpdating ? 'Saving...' : 'Edit',
+ *           action: () => update({ status: 'updated' }),
+ *         },
+ *       ]}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function useReactiveCard<T extends Record<string, any>>(options: ReactiveCardOptions<T>): ReactiveCardResult<T>;
+
+/**
+ * @mdxui/terminal SaaS Collections
+ *
+ * Pre-built Zod schemas and collections for common SaaS primitives:
+ * - Users: Authentication and user management
+ * - APIKeys: API key management with permissions
+ * - Webhooks: Webhook configuration and event subscriptions
+ * - Teams: Team/organization management with members
+ * - Usage: Usage metrics tracking
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UsersCollection,
+ *   APIKeysCollection,
+ *   WebhooksCollection,
+ *   TeamsCollection,
+ *   UsageCollection,
+ *   type User,
+ *   type APIKey,
+ * } from '@mdxui/terminal'
+ *
+ * // Create collections
+ * const users = UsersCollection()
+ * const apiKeys = APIKeysCollection()
+ *
+ * // Insert data
+ * await users.insert({
+ *   id: 'user-1',
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   role: 'admin',
+ *   createdAt: new Date(),
+ * })
+ *
+ * // Query
+ * const admins = await users.findMany({
+ *   where: { role: 'admin' }
+ * })
+ * ```
+ */
+
+/**
+ * User role enum - defines access levels
+ */
+declare const UserRoleSchema: z.ZodEnum<["admin", "user", "viewer"]>;
+/**
+ * User schema - validates user account information
+ *
+ * @example
+ * ```typescript
+ * const user = UserSchema.parse({
+ *   id: 'user-1',
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   role: 'admin',
+ *   createdAt: new Date(),
+ * })
+ * ```
+ */
+declare const UserSchema: z.ZodObject<{
+    /** Unique user identifier */
+    id: z.ZodString;
+    /** User's display name */
+    name: z.ZodString;
+    /** User's email address (validated format) */
+    email: z.ZodString;
+    /** User's role: admin, user, or viewer */
+    role: z.ZodEnum<["admin", "user", "viewer"]>;
+    /** When the user account was created */
+    createdAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    name: string;
+    id: string;
+    role: "user" | "admin" | "viewer";
+    createdAt: Date;
+}, {
+    email: string;
+    name: string;
+    id: string;
+    role: "user" | "admin" | "viewer";
+    createdAt: Date;
+}>;
+/**
+ * APIKey schema - validates API key configuration
+ *
+ * @example
+ * ```typescript
+ * const key = APIKeySchema.parse({
+ *   id: 'key-1',
+ *   key: 'sk_test_abc123',
+ *   name: 'Development',
+ *   permissions: ['read:api', 'write:webhooks'],
+ *   expiresAt: new Date('2025-12-31'),
+ * })
+ * ```
+ */
+declare const APIKeySchema: z.ZodObject<{
+    /** Unique key identifier */
+    id: z.ZodString;
+    /** The actual API key string (secret) */
+    key: z.ZodString;
+    /** Human-readable name for the key */
+    name: z.ZodString;
+    /** Array of permission strings this key grants */
+    permissions: z.ZodArray<z.ZodString, "many">;
+    /** When the key expires */
+    expiresAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    id: string;
+    permissions: string[];
+    expiresAt: Date;
+}, {
+    name: string;
+    key: string;
+    id: string;
+    permissions: string[];
+    expiresAt: Date;
+}>;
+/**
+ * Webhook schema - validates webhook configuration
+ *
+ * @example
+ * ```typescript
+ * const webhook = WebhookSchema.parse({
+ *   id: 'webhook-1',
+ *   url: 'https://example.com/webhook',
+ *   events: ['user.created', 'user.updated'],
+ *   secret: 'whsec_test_abc123',
+ *   active: true,
+ * })
+ * ```
+ */
+declare const WebhookSchema: z.ZodObject<{
+    /** Unique webhook identifier */
+    id: z.ZodString;
+    /** Webhook endpoint URL (validated format) */
+    url: z.ZodString;
+    /** Events this webhook listens to (non-empty array) */
+    events: z.ZodArray<z.ZodString, "many">;
+    /** Webhook signing secret */
+    secret: z.ZodString;
+    /** Whether the webhook is currently active */
+    active: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    active: boolean;
+    id: string;
+    events: string[];
+    secret: string;
+}, {
+    url: string;
+    active: boolean;
+    id: string;
+    events: string[];
+    secret: string;
+}>;
+/**
+ * Team schema - validates team configuration
+ *
+ * @example
+ * ```typescript
+ * const team = TeamSchema.parse({
+ *   id: 'team-1',
+ *   name: 'Engineering',
+ *   members: ['user-1', 'user-2', 'user-3'],
+ * })
+ * ```
+ */
+declare const TeamSchema: z.ZodObject<{
+    /** Unique team identifier */
+    id: z.ZodString;
+    /** Team name */
+    name: z.ZodString;
+    /** Array of user IDs who are members */
+    members: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    members: string[];
+}, {
+    name: string;
+    id: string;
+    members: string[];
+}>;
+/**
+ * Usage schema - validates usage metrics
+ *
+ * @example
+ * ```typescript
+ * const usage = UsageSchema.parse({
+ *   id: 'usage-1',
+ *   metric: 'api_calls',
+ *   value: 1500,
+ *   timestamp: new Date(),
+ * })
+ * ```
+ */
+declare const UsageSchema: z.ZodObject<{
+    /** Unique usage record identifier */
+    id: z.ZodString;
+    /** Name of the metric being tracked */
+    metric: z.ZodString;
+    /** Numeric value of the metric */
+    value: z.ZodNumber;
+    /** When this metric was recorded */
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    id: string;
+    metric: string;
+    timestamp: Date;
+}, {
+    value: number;
+    id: string;
+    metric: string;
+    timestamp: Date;
+}>;
+/** User type - inferred from UserSchema */
+type User = z.infer<typeof UserSchema>;
+/** APIKey type - inferred from APIKeySchema */
+type APIKey = z.infer<typeof APIKeySchema>;
+/** Webhook type - inferred from WebhookSchema */
+type Webhook = z.infer<typeof WebhookSchema>;
+/** Team type - inferred from TeamSchema */
+type Team = z.infer<typeof TeamSchema>;
+/** Usage type - inferred from UsageSchema */
+type Usage = z.infer<typeof UsageSchema>;
+/** User role type - admin, user, or viewer */
+type UserRole = z.infer<typeof UserRoleSchema>;
+/**
+ * Creates a Users collection with Zod validation
+ *
+ * @returns A typed Collection<User> for managing user accounts
+ *
+ * @example
+ * ```typescript
+ * const users = UsersCollection()
+ *
+ * // Insert a user
+ * const user = await users.insert({
+ *   id: 'user-1',
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   role: 'admin',
+ *   createdAt: new Date(),
+ * })
+ *
+ * // Find admins
+ * const admins = await users.findMany({
+ *   where: { role: 'admin' }
+ * })
+ *
+ * // Subscribe to changes
+ * const unsubscribe = users.subscribe((allUsers) => {
+ *   console.log('Users changed:', allUsers.length)
+ * })
+ * ```
+ */
+declare function UsersCollection(): Collection<User>;
+/**
+ * Creates an APIKeys collection with Zod validation
+ *
+ * @returns A typed Collection<APIKey> for managing API keys
+ *
+ * @example
+ * ```typescript
+ * const apiKeys = APIKeysCollection()
+ *
+ * // Create a new key
+ * const key = await apiKeys.insert({
+ *   id: 'key-1',
+ *   key: 'sk_test_abc123',
+ *   name: 'Development',
+ *   permissions: ['read:api'],
+ *   expiresAt: new Date('2025-12-31'),
+ * })
+ *
+ * // Find non-expired keys
+ * const validKeys = await apiKeys.findMany({
+ *   where: { expiresAt: { $gt: new Date() } }
+ * })
+ * ```
+ */
+declare function APIKeysCollection(): Collection<APIKey>;
+/**
+ * Creates a Webhooks collection with Zod validation
+ *
+ * @returns A typed Collection<Webhook> for managing webhook configurations
+ *
+ * @example
+ * ```typescript
+ * const webhooks = WebhooksCollection()
+ *
+ * // Create a webhook
+ * await webhooks.insert({
+ *   id: 'webhook-1',
+ *   url: 'https://example.com/webhook',
+ *   events: ['user.created'],
+ *   secret: 'whsec_abc123',
+ *   active: true,
+ * })
+ *
+ * // Find active webhooks
+ * const active = await webhooks.findMany({
+ *   where: { active: true }
+ * })
+ * ```
+ */
+declare function WebhooksCollection(): Collection<Webhook>;
+/**
+ * Creates a Teams collection with Zod validation
+ *
+ * @returns A typed Collection<Team> for managing teams and their members
+ *
+ * @example
+ * ```typescript
+ * const teams = TeamsCollection()
+ *
+ * // Create a team
+ * await teams.insert({
+ *   id: 'team-1',
+ *   name: 'Engineering',
+ *   members: ['user-1', 'user-2'],
+ * })
+ *
+ * // Add a member
+ * await teams.update(
+ *   { id: 'team-1' },
+ *   { members: ['user-1', 'user-2', 'user-3'] }
+ * )
+ * ```
+ */
+declare function TeamsCollection(): Collection<Team>;
+/**
+ * Creates a Usage collection with Zod validation
+ *
+ * @returns A typed Collection<Usage> for tracking usage metrics
+ *
+ * @example
+ * ```typescript
+ * const usage = UsageCollection()
+ *
+ * // Record usage
+ * await usage.insert({
+ *   id: 'usage-1',
+ *   metric: 'api_calls',
+ *   value: 1500,
+ *   timestamp: new Date(),
+ * })
+ *
+ * // Get usage for a specific metric
+ * const apiCalls = await usage.findMany({
+ *   where: { metric: 'api_calls' },
+ *   orderBy: { timestamp: 'desc' }
+ * })
+ * ```
+ */
+declare function UsageCollection(): Collection<Usage>;
+
+export { type APIKey, APIKeySchema, APIKeysCollection, type Collection, type ComparisonOperators, type ConflictResolution, type DB, type DBConfig, DBProvider, type DBProviderProps, type DOSyncAdapter, type DOSyncConfig, type FieldFilter, type FindManyOptions, type MetricValue, type MutationOperation, type MutationOptions, type MutationResult, type OrderByClause, type OrderDirection, type PaginationState, type QueryOptions, type QueryResult, type ReactiveCardOptions, type ReactiveCardResult, type ReactiveDataOptions, type ReactiveDataResult, type ReactiveListOptions, type ReactiveMetricsOptions, type ReactiveMetricsResult, type ReactiveTableOptions, type ReconnectOptions, type SelectionState, type SortState, type SyncAdapter, type Team, TeamSchema, TeamsCollection, type Usage, UsageCollection, UsageSchema, type User, type UserRole, UserRoleSchema, UserSchema, UsersCollection, type Webhook, WebhookSchema, WebhooksCollection, type WhereClause, createCollection, createDB, createDOSync, useDBContext, useMutation, useQuery, useReactiveCard, useReactiveData, useReactiveList, useReactiveMetrics, useReactiveTable };