@xnetjs/data-bridge 0.0.2 → 0.0.3

package/dist/types-BRvuTwEn.d.ts

@@ -0,0 +1,547 @@
+import * as _xnetjs_data from '@xnetjs/data';
+import { NodeState, SchemaIRI, PropertyBuilder, DefinedSchema, InferCreateProps, NodeQueryPageCountMode, NodeQueryPlanMetadata, NodeBatchWriteInput, NodeBatchWriteResult, TransactionOperation, NodeChangeEvent, ListNodesOptions } from '@xnetjs/data';
+import { Awareness } from 'y-protocols/awareness';
+import { Doc } from 'yjs';
+
+/**
+ * Query stream event types and deterministic reducers.
+ */
+
+type QueryStreamEvent = {
+    type: 'snapshot';
+    nodes: NodeState[];
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'insert';
+    node: NodeState;
+    index?: number;
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'update';
+    nodeId: string;
+    node: NodeState;
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'delete';
+    nodeId: string;
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'reset';
+    reason: QueryStreamResetReason;
+    nodes?: NodeState[];
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'progress';
+    progress: QueryStreamProgress;
+    metadata?: QueryMetadata | null;
+} | {
+    type: 'error';
+    error: string;
+    code?: string;
+    recoverable?: boolean;
+    metadata?: QueryMetadata | null;
+};
+type QueryStreamState = {
+    data: NodeState[] | null;
+    metadata: QueryMetadata | null;
+    progress: QueryStreamProgress | null;
+    error: string | null;
+    status: QueryStreamStatus;
+};
+declare function createQueryStreamState(input?: {
+    data?: NodeState[] | null;
+    metadata?: QueryMetadata | null;
+    progress?: QueryStreamProgress | null;
+    error?: string | null;
+    status?: QueryStreamStatus;
+}): QueryStreamState;
+declare function reduceQueryStreamEvent(state: QueryStreamState, event: QueryStreamEvent): QueryStreamState;
+declare function reduceQueryStreamEvents(state: QueryStreamState, events: readonly QueryStreamEvent[]): QueryStreamState;
+
+/**
+ * Versioned protocol types for future remote Node descriptor reads.
+ */
+
+declare const REMOTE_NODE_QUERY_PROTOCOL = "xnet.node-query";
+declare const REMOTE_NODE_QUERY_PROTOCOL_VERSION = 1;
+type RemoteNodeQuerySource = Extract<QuerySourcePreference, 'hub' | 'federated'>;
+type RemoteNodeQueryMode = Extract<QueryExecutionMode, 'local-then-remote' | 'remote' | 'live' | 'stream'>;
+type RemoteNodeQueryAuth = {
+    bearerToken?: string;
+    ucan?: string;
+    capabilities?: string[];
+};
+type RemoteNodeQueryClientState = {
+    localSnapshotAt?: number;
+    knownNodeIds?: string[];
+};
+type RemoteQueryCompleteness = QueryCompletenessMetadata;
+type RemoteQueryStaleness = QueryStalenessMetadata;
+type RemoteQueryVerification = QueryVerificationMetadata;
+type RemoteNodeQueryRequest = {
+    protocol: typeof REMOTE_NODE_QUERY_PROTOCOL;
+    version: typeof REMOTE_NODE_QUERY_PROTOCOL_VERSION;
+    requestId: string;
+    descriptor: QueryDescriptor;
+    mode: RemoteNodeQueryMode;
+    source: RemoteNodeQuerySource;
+    requestedAt: number;
+    auth?: RemoteNodeQueryAuth;
+    client?: RemoteNodeQueryClientState;
+};
+type RemoteNodeQuerySuccessResponse = {
+    type: 'node-query/result';
+    requestId: string;
+    source: RemoteNodeQuerySource;
+    nodes: NodeState[];
+    pageInfo: QueryPageInfo;
+    metadata: QueryMetadata;
+    completeness: RemoteQueryCompleteness;
+    staleness: RemoteQueryStaleness;
+    verification: RemoteQueryVerification;
+};
+type RemoteNodeQueryErrorResponse = {
+    type: 'node-query/error';
+    requestId: string;
+    source: RemoteNodeQuerySource;
+    code: 'AUTH_DENIED' | 'REMOTE_UNAVAILABLE' | 'QUERY_UNSUPPORTED' | 'TIMEOUT' | 'VERIFICATION_FAILED' | 'UNKNOWN';
+    message: string;
+    retryAfterMs?: number;
+};
+type RemoteNodeQueryResponse = RemoteNodeQuerySuccessResponse | RemoteNodeQueryErrorResponse;
+type RemoteNodeQueryStreamObserver = {
+    next(event: QueryStreamEvent): void;
+    error?(error: Error): void;
+    complete?(): void;
+};
+type RemoteNodeQueryStreamController = {
+    unsubscribe(): void;
+};
+type RemoteNodeQueryStreamSubscription = RemoteNodeQueryStreamController | (() => void) | void;
+type RemoteNodeQueryInvalidationReason = 'poke' | 'descriptor-invalidated' | 'schema-invalidated' | 'node-invalidated';
+type RemoteNodeQueryInvalidation = {
+    type: 'node-query/invalidate';
+    source?: RemoteNodeQuerySource;
+    requestId?: string;
+    descriptor?: QueryDescriptor;
+    schemaId?: SchemaIRI;
+    nodeIds?: string[];
+    reason?: RemoteNodeQueryInvalidationReason;
+    invalidatedAt?: number;
+};
+type RemoteNodeQueryInvalidationObserver = {
+    next(event: RemoteNodeQueryInvalidation): void;
+    error?(error: Error): void;
+    complete?(): void;
+};
+type RemoteNodeQueryInvalidationController = {
+    unsubscribe(): void;
+};
+type RemoteNodeQueryInvalidationSubscription = RemoteNodeQueryInvalidationController | (() => void) | void;
+type RemoteNodeQueryClient = {
+    query(request: RemoteNodeQueryRequest): Promise<RemoteNodeQueryResponse>;
+    stream?(request: RemoteNodeQueryRequest, observer: RemoteNodeQueryStreamObserver): RemoteNodeQueryStreamSubscription | Promise<RemoteNodeQueryStreamSubscription>;
+    subscribeInvalidations?(observer: RemoteNodeQueryInvalidationObserver): RemoteNodeQueryInvalidationSubscription | Promise<RemoteNodeQueryInvalidationSubscription>;
+};
+declare function isRemoteNodeQuerySource(source: QuerySourcePreference | undefined): source is RemoteNodeQuerySource;
+declare function createRemoteNodeQueryRequest(input: {
+    requestId: string;
+    descriptor: QueryDescriptor;
+    mode?: RemoteNodeQueryMode;
+    source: RemoteNodeQuerySource;
+    requestedAt?: number;
+    auth?: RemoteNodeQueryAuth;
+    client?: RemoteNodeQueryClientState;
+}): RemoteNodeQueryRequest;
+declare function isRemoteNodeQuerySuccess(response: RemoteNodeQueryResponse): response is RemoteNodeQuerySuccessResponse;
+declare function isRemoteNodeQueryError(response: RemoteNodeQueryResponse): response is RemoteNodeQueryErrorResponse;
+
+/**
+ * Sort direction for ordering results
+ */
+type SortDirection = 'asc' | 'desc';
+/**
+ * System fields that can be used for ordering
+ */
+type SystemOrderField = 'createdAt' | 'updatedAt';
+type QuerySpatialPoint = {
+    x: number;
+    y: number;
+};
+type QuerySpatialRect = QuerySpatialPoint & {
+    width: number;
+    height: number;
+};
+type QuerySpatialPointFields = {
+    x: string;
+    y: string;
+};
+type QuerySpatialRectFields = QuerySpatialPointFields & {
+    width?: string;
+    height?: string;
+};
+type QuerySpatialWindow = {
+    kind: 'window';
+    rect: QuerySpatialRect;
+    fields: QuerySpatialRectFields;
+    overscan?: number;
+};
+type QuerySpatialRadius = {
+    kind: 'radius';
+    center: QuerySpatialPoint;
+    radius: number;
+    fields: QuerySpatialPointFields;
+};
+type QuerySpatialFilter = QuerySpatialWindow | QuerySpatialRadius;
+type QuerySearchField = 'title' | 'content';
+type QuerySearchFilter = {
+    text: string;
+    fields?: QuerySearchField[];
+};
+type QueryMaterializedViewOptions = {
+    viewId: string;
+    maxAgeMs?: number;
+    forceRefresh?: boolean;
+};
+type QueryPageCountMode = NodeQueryPageCountMode;
+type QueryExecutionMode = 'local' | 'local-then-remote' | 'remote' | 'live' | 'stream';
+type QuerySourcePreference = 'auto' | 'local' | 'hub' | 'federated';
+type QueryPageOptions = {
+    first: number;
+    after?: string;
+    count?: NodeQueryPageCountMode;
+};
+/**
+ * Options for querying nodes via the DataBridge.
+ * Maps to the filter options used by useQuery.
+ */
+interface QueryOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
+    /** Filter by single node ID (makes this a single-node query) */
+    nodeId?: string;
+    /** Filter conditions (property: value) */
+    where?: Partial<InferCreateProps<P>>;
+    /** Include soft-deleted nodes */
+    includeDeleted?: boolean;
+    /** Sort by property or system field */
+    orderBy?: {
+        [K in keyof InferCreateProps<P> | SystemOrderField]?: SortDirection;
+    };
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Recommended forward-compatible pagination shape. `first` lowers to `limit`. */
+    page?: QueryPageOptions;
+    /** Spatial filtering for viewport windows, canvases, or geo-style proximity queries */
+    spatial?: QuerySpatialFilter;
+    /** Tokenized full-text search over searchable node fields */
+    search?: string | QuerySearchFilter;
+    /** Stable database view cache key for JIT materialized result sets */
+    materializedView?: string | QueryMaterializedViewOptions;
+    /** Future execution mode hint. Local execution remains the only active runtime today. */
+    mode?: QueryExecutionMode;
+    /** Future source preference hint for hub or federated reads. */
+    source?: QuerySourcePreference;
+}
+/**
+ * Canonical descriptor for a live query.
+ * Shared across hooks and bridge implementations.
+ */
+interface QueryDescriptor {
+    /** Schema IRI for the query */
+    schemaId: _xnetjs_data.SchemaIRI;
+    /** Optional single-node query */
+    nodeId?: string;
+    /** Normalized property filters */
+    where?: Record<string, unknown>;
+    /** Whether soft-deleted nodes are included */
+    includeDeleted: boolean;
+    /** Normalized ordering rules */
+    orderBy?: Record<string, SortDirection>;
+    /** Limit applied after filtering and sorting */
+    limit?: number;
+    /** Offset applied after filtering and sorting */
+    offset?: number;
+    /** Cursor applied after filtering and sorting */
+    after?: string;
+    /** Count strategy requested by the page options */
+    count?: NodeQueryPageCountMode;
+    /** Optional spatial filter metadata used by canvas-style queries */
+    spatial?: QuerySpatialFilter;
+    /** Optional full-text filter metadata */
+    search?: QuerySearchFilter;
+    /** Optional stable view cache key for storage-backed materialization */
+    materializedView?: QueryMaterializedViewOptions;
+    /** Execution mode hint for routing local, remote, live, or streamed reads */
+    mode?: QueryExecutionMode;
+    /** Preferred read source for future hub/federated execution */
+    source?: QuerySourcePreference;
+}
+type QuerySource = 'local' | 'memory' | 'hub' | 'federated' | 'hybrid';
+type NodeQueryRouterThresholds = {
+    /** Local row counts below this value stay local for `source: "auto"` reads. */
+    localRowThreshold: number;
+    /** Local row counts at or above this value prefer a hub refresh for `source: "auto"` reads. */
+    hybridRowThreshold: number;
+    /** Full-text descriptors request remote completion when a remote client exists. */
+    searchToRemote: boolean;
+    /** Spatial descriptors request remote completion when a remote client exists. */
+    spatialToRemote: boolean;
+};
+type QueryRoutingMetadata = {
+    source: QuerySource;
+    reason: string;
+    localRowCount?: number;
+    thresholds: Pick<NodeQueryRouterThresholds, 'localRowThreshold' | 'hybridRowThreshold'>;
+};
+interface QueryPageInfo {
+    totalCount: number | null;
+    countMode: QueryPageCountMode;
+    hasMore: boolean;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string;
+    endCursor?: string;
+    loadedCount: number;
+}
+interface QueryMaterializedMetadata {
+    viewId: string;
+    cacheHit: boolean;
+    generatedAt: number;
+    invalidatedAt?: number;
+    rowCount: number;
+}
+type QueryCompletenessMetadata = {
+    level: 'complete' | 'partial' | 'unknown';
+    reason?: 'auth-filtered' | 'federation-partial' | 'page-limited' | 'remote-unavailable' | 'source-timeout' | 'verification-failed';
+    sourceCount?: number;
+};
+type QueryStalenessMetadata = {
+    level: 'fresh' | 'stale' | 'unknown';
+    asOf?: number;
+    maxAgeMs?: number;
+};
+type QueryVerificationMetadata = {
+    status: 'verified' | 'unverified' | 'failed' | 'mixed';
+    verifiedNodeIds?: string[];
+    failedNodeIds?: string[];
+};
+type QueryStreamProgressPhase = 'connecting' | 'snapshot' | 'catching-up' | 'live' | 'reconnecting' | 'complete';
+type QueryStreamProgress = {
+    phase: QueryStreamProgressPhase;
+    loaded?: number;
+    total?: number | null;
+    message?: string;
+};
+type QueryStreamResetReason = 'descriptor-changed' | 'reconnect' | 'server-reset' | 'client-reset';
+type QueryStreamStatus = 'idle' | 'loading' | 'ready' | 'error';
+type QueryStreamEventType = 'snapshot' | 'insert' | 'update' | 'delete' | 'reset' | 'progress' | 'error';
+type QueryStreamMetadata = {
+    status: QueryStreamStatus;
+    lastEvent: QueryStreamEventType;
+    lastEventAt: number;
+    progress?: QueryStreamProgress | null;
+    error?: string | null;
+    resetReason?: QueryStreamResetReason;
+};
+interface QueryMetadata {
+    source: QuerySource;
+    updatedAt: number;
+    pageInfo: QueryPageInfo;
+    plan?: NodeQueryPlanMetadata;
+    materialized?: QueryMaterializedMetadata;
+    routing?: QueryRoutingMetadata;
+    completeness?: QueryCompletenessMetadata;
+    staleness?: QueryStalenessMetadata;
+    verification?: QueryVerificationMetadata;
+    stream?: QueryStreamMetadata;
+    error?: string;
+}
+/**
+ * A subscription to a query result.
+ * Compatible with React's useSyncExternalStore pattern.
+ *
+ * @typeParam P - Property builder type (unused at runtime, for type inference)
+ */
+interface QuerySubscription<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
+    /** Get current snapshot (synchronous - reads from cache). Returns null if loading. */
+    getSnapshot(): NodeState[] | null;
+    /** Get current query metadata, if the bridge can provide it. */
+    getMetadata?(): QueryMetadata | null;
+    /** Subscribe to updates (React will call this) */
+    subscribe(callback: () => void): () => void;
+}
+/**
+ * Result of a create operation
+ */
+interface CreateResult {
+    node: NodeState;
+}
+/**
+ * Result of an update operation
+ */
+interface UpdateResult {
+    node: NodeState;
+}
+/**
+ * Result of a bridge-level atomic transaction.
+ *
+ * A structured-clone-safe subset of NodeStore's `TransactionResult`: the
+ * signed change list stays on the data thread; callers only need the
+ * materialized results and temp ID mapping.
+ */
+interface BridgeTransactionResult {
+    /** The batch ID shared by all changes */
+    batchId: string;
+    /** Results for each operation (NodeState or null for delete) */
+    results: (NodeState | null)[];
+    /** Map from temp ID → generated real ID (empty if no temp IDs were used) */
+    tempIds: Record<string, string>;
+}
+/**
+ * Result of acquiring a Y.Doc for editing.
+ * The doc is kept in sync with the data thread via the bridge.
+ */
+interface AcquiredDoc {
+    /** The Y.Doc instance (on main thread for TipTap binding) */
+    doc: Doc;
+    /** Awareness instance for presence/cursors */
+    awareness: Awareness;
+}
+/**
+ * Sync connection status
+ */
+type SyncStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+/**
+ * Configuration for initializing a DataBridge
+ */
+interface DataBridgeConfig {
+    /** Database name for storage */
+    dbName?: string;
+    /** Author's DID for signing changes */
+    authorDID: string;
+    /** Ed25519 signing key */
+    signingKey: Uint8Array;
+    /** Signaling server URL for sync */
+    signalingUrl?: string;
+    /**
+     * Optional MessagePort connected to a storage worker (e.g. the SQLite
+     * worker via `WebSQLiteProxy.createMessagePort()`). Worker-backed bridges
+     * transfer it to the data worker so storage calls bypass the main thread.
+     */
+    storagePort?: MessagePort;
+    /** Optional main-thread remote Node query client for progressive hub/federated reads. */
+    remoteNodeQueryClient?: RemoteNodeQueryClient;
+    /** Optional source:auto routing thresholds for main-thread Node descriptor reads. */
+    remoteNodeQueryRouting?: Partial<NodeQueryRouterThresholds>;
+}
+/**
+ * The DataBridge interface abstracts data access across different platforms.
+ *
+ * Implementations:
+ * - MainThreadBridge: Direct NodeStore access (Phase 0, fallback)
+ * - WorkerBridge: Web Worker via Comlink (Phase 1)
+ * - IPCBridge: Electron utility process (Phase 2)
+ * - NativeBridge: React Native Turbo Module (Phase 5)
+ *
+ * All implementations provide the same API, allowing React hooks to work
+ * identically across all platforms.
+ */
+interface DataBridge {
+    /**
+     * Create a subscription to a query result.
+     * Returns an object compatible with useSyncExternalStore.
+     *
+     * The subscription loads data asynchronously and updates the cache.
+     * getSnapshot() returns null while loading, then the result array.
+     */
+    query<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, options?: QueryOptions<P>): QuerySubscription<P>;
+    /**
+     * Force a reload for a canonical query descriptor.
+     */
+    reloadQuery?(descriptor: QueryDescriptor): Promise<void>;
+    /**
+     * Create a new node.
+     */
+    create<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, data: InferCreateProps<P>, id?: string): Promise<NodeState>;
+    /**
+     * Update an existing node.
+     */
+    update(nodeId: string, changes: Record<string, unknown>): Promise<NodeState>;
+    /**
+     * Soft-delete a node.
+     */
+    delete(nodeId: string): Promise<void>;
+    /**
+     * Restore a soft-deleted node.
+     */
+    restore(nodeId: string): Promise<NodeState>;
+    /**
+     * Execute a storage-owned batch write when the runtime supports it.
+     */
+    bulkWrite(input: NodeBatchWriteInput): Promise<NodeBatchWriteResult>;
+    /**
+     * Execute multiple operations atomically with temp ID resolution.
+     *
+     * All operations succeed or fail together. Implemented by every bridge
+     * that owns (or proxies to) a transaction-capable NodeStore; consumers
+     * should feature-detect rather than reaching for `bridge.nodeStore`.
+     */
+    transaction?(operations: TransactionOperation[]): Promise<BridgeTransactionResult>;
+    /**
+     * Acquire a Y.Doc for editing. Returns the doc with current state.
+     * The doc receives updates from the data thread via the bridge.
+     */
+    acquireDoc?(nodeId: string): Promise<AcquiredDoc>;
+    /**
+     * Release a Y.Doc when no longer editing.
+     * The data thread continues syncing in the background.
+     */
+    releaseDoc?(nodeId: string): void;
+    /**
+     * Initialize the bridge with configuration.
+     * For MainThreadBridge, this is a no-op (already initialized with NodeStore).
+     */
+    initialize?(config: DataBridgeConfig): Promise<void>;
+    /**
+     * Clean up resources.
+     */
+    destroy(): void;
+    /**
+     * Current sync status.
+     */
+    readonly status: SyncStatus;
+    /**
+     * Subscribe to status changes.
+     */
+    on(event: 'status', handler: (status: SyncStatus) => void): () => void;
+    /**
+     * Get the underlying NodeStore directly.
+     * Only available in MainThreadBridge for backward compatibility.
+     * Will be removed in later phases.
+     *
+     * @deprecated Reach for bridge-level APIs (`transaction`, `bulkWrite`,
+     * `get`, `subscribeToChanges`) instead — worker-backed bridges have no
+     * main-thread store, so this is `undefined` there. Long-lived services
+     * (SyncManager, search indexing, devtools) should use the provider-owned
+     * store from XNetProvider context, not the bridge.
+     */
+    readonly nodeStore?: _xnetjs_data.NodeStore;
+    /**
+     * Subscribe to store changes directly.
+     * Only available in MainThreadBridge for backward compatibility.
+     */
+    subscribeToChanges?(listener: (event: NodeChangeEvent) => void): () => void;
+    /**
+     * Get a single node by ID directly.
+     * Only available in MainThreadBridge for backward compatibility.
+     */
+    get?(nodeId: string): Promise<NodeState | null>;
+    /**
+     * List nodes with options directly.
+     * Only available in MainThreadBridge for backward compatibility.
+     */
+    list?(options?: ListNodesOptions): Promise<NodeState[]>;
+}
+
+export { type RemoteNodeQueryInvalidationReason as $, type AcquiredDoc as A, type BridgeTransactionResult as B, type QuerySpatialRectFields as C, type DataBridge as D, type QuerySpatialWindow as E, type QueryStreamEventType as F, type QueryStreamMetadata as G, type QueryStalenessMetadata as H, type SortDirection as I, type SystemOrderField as J, type CreateResult as K, REMOTE_NODE_QUERY_PROTOCOL as L, REMOTE_NODE_QUERY_PROTOCOL_VERSION as M, type NodeQueryRouterThresholds as N, createRemoteNodeQueryRequest as O, isRemoteNodeQueryError as P, type QueryOptions as Q, type RemoteNodeQueryClient as R, type SyncStatus as S, isRemoteNodeQuerySource as T, type UpdateResult as U, isRemoteNodeQuerySuccess as V, type RemoteNodeQueryAuth as W, type RemoteNodeQueryClientState as X, type RemoteNodeQueryInvalidation as Y, type RemoteNodeQueryInvalidationController as Z, type RemoteNodeQueryInvalidationObserver as _, type QuerySubscription as a, type RemoteNodeQueryInvalidationSubscription as a0, type RemoteNodeQueryRequest as a1, type RemoteNodeQueryResponse as a2, type RemoteNodeQueryStreamController as a3, type RemoteNodeQueryStreamObserver as a4, type RemoteNodeQueryStreamSubscription as a5, type RemoteQueryCompleteness as a6, type RemoteQueryStaleness as a7, type RemoteQueryVerification as a8, createQueryStreamState as a9, reduceQueryStreamEvent as aa, reduceQueryStreamEvents as ab, type QueryStreamEvent as ac, type QueryStreamProgress as ad, type QueryStreamProgressPhase as ae, type QueryStreamResetReason as af, type QueryStreamState as ag, type QueryStreamStatus as ah, type QueryDescriptor as b, type DataBridgeConfig as c, type QueryMetadata as d, type QuerySource as e, type RemoteNodeQueryMode as f, type RemoteNodeQuerySource as g, type QueryRoutingMetadata as h, type RemoteNodeQueryErrorResponse as i, type RemoteNodeQuerySuccessResponse as j, type QueryVerificationMetadata as k, type QueryCompletenessMetadata as l, type QueryExecutionMode as m, type QueryMaterializedMetadata as n, type QueryMaterializedViewOptions as o, type QueryPageInfo as p, type QueryPageCountMode as q, type QueryPageOptions as r, type QuerySearchField as s, type QuerySearchFilter as t, type QuerySourcePreference as u, type QuerySpatialFilter as v, type QuerySpatialPoint as w, type QuerySpatialPointFields as x, type QuerySpatialRadius as y, type QuerySpatialRect as z };

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+import '@xnetjs/data';
+export { A as AcquiredDoc, B as BridgeTransactionResult, K as CreateResult, D as DataBridge, c as DataBridgeConfig, N as NodeQueryRouterThresholds, l as QueryCompletenessMetadata, b as QueryDescriptor, m as QueryExecutionMode, n as QueryMaterializedMetadata, o as QueryMaterializedViewOptions, d as QueryMetadata, Q as QueryOptions, q as QueryPageCountMode, p as QueryPageInfo, r as QueryPageOptions, h as QueryRoutingMetadata, s as QuerySearchField, t as QuerySearchFilter, e as QuerySource, u as QuerySourcePreference, v as QuerySpatialFilter, w as QuerySpatialPoint, x as QuerySpatialPointFields, y as QuerySpatialRadius, z as QuerySpatialRect, C as QuerySpatialRectFields, E as QuerySpatialWindow, H as QueryStalenessMetadata, F as QueryStreamEventType, G as QueryStreamMetadata, ad as QueryStreamProgress, ae as QueryStreamProgressPhase, af as QueryStreamResetReason, ah as QueryStreamStatus, a as QuerySubscription, k as QueryVerificationMetadata, I as SortDirection, S as SyncStatus, J as SystemOrderField, U as UpdateResult } from './types-BRvuTwEn.js';
+import 'y-protocols/awareness';
+import 'yjs';