@xnetjs/data 0.0.2 → 0.0.3

package/dist/store/index.d.ts

@@ -0,0 +1,391 @@
+import { g as NodeStorageAdapter, r as NodeChange, i as NodeId, h as NodeState, aa as NodeBatchPreflightResult, a3 as ImportNodesOptions, a5 as ApplyNodeBatchInput, a6 as ApplyNodeBatchResult, L as ListNodesOptions, ae as CountNodesOptions, a2 as SetNodeOptions, j as NodeQueryDescriptor, k as NodeQueryResult, S as SchemaIRI, a4 as RebuildNodeIndexesOptions } from '../types-Def-5Nka.js';
+export { av as ConflictResult, ay as ContentKeyCache, C as CreateNodeOptions, ab as DeterministicNodeBatchWriteInput, m as DeterministicNodeImportDraft, G as GetWithMigrationOptions, n as ImportDeterministicNodesOptions, o as ImportDeterministicNodesResult, s as MergeConflict, M as MigratedNodeState, az as MigrationInfo, aw as NodeBatchChangeEvent, u as NodeBatchChangeListener, a7 as NodeBatchIndexMode, a8 as NodeBatchNotificationMode, a9 as NodeBatchSyncMode, p as NodeBatchWriteInput, ac as NodeBatchWritePolicy, q as NodeBatchWriteResult, ad as NodeBatchWriteTimings, v as NodeChangeEvent, t as NodeChangeListener, ax as NodeContentCipher, a0 as NodePayload, ar as NodeQueryCursor, aq as NodeQueryCursorOrderEntry, ao as NodeQueryMaterializedViewOptions, as as NodeQueryOptions, N as NodeQueryPageCountMode, ap as NodeQueryPageOptions, au as NodeQueryParityCheckMetadata, at as NodeQueryPlanMetadata, am as NodeQuerySearchField, an as NodeQuerySearchFilter, al as NodeQuerySpatialFilter, af as NodeQuerySpatialPoint, ah as NodeQuerySpatialPointFields, ak as NodeQuerySpatialRadius, ag as NodeQuerySpatialRect, ai as NodeQuerySpatialRectFields, aj as NodeQuerySpatialWindow, f as NodeStoreOptions, bi as OperationNodeBatchWriteInput, $ as PropertyKey, bj as PropertyLookup, a1 as PropertyTimestamp, aR as SchemaLookup, c as SortDirection, d as SystemOrderField, aO as TEMP_ID_PREFIX, aS as TempIdResolution, T as TransactionOperation, l as TransactionResult, U as UpdateNodeOptions, aI as applyNodeQueryDescriptor, aA as createNodeQueryDescriptor, bk as createPropertyLookup, aQ as createSchemaLookup, aC as decodeNodeQueryCursor, aB as encodeNodeQueryCursor, aG as filterNodeQueryResults, aJ as getNodeQuerySearchTokens, aN as isTempId, aF as matchesNodeQueryDescriptor, aK as nodeQueryDescriptorNeedsBoundedReload, aD as nodeQueryDescriptorToOptions, aP as resolveTempIds, aE as serializeNodeQueryDescriptor, aH as sortNodeQueryResults, aM as withoutNodeQueryMaterializedView, aL as withoutNodeQueryPagination } from '../types-Def-5Nka.js';
+export { G as QUERY_AST_VERSION, r as QueryAST, n as QueryASTAggregate, A as QueryASTAggregateExecution, m as QueryASTAggregateFunction, y as QueryASTAggregateGroup, x as QueryASTAggregatePlan, z as QueryASTAggregateResult, d as QueryASTComparisonPredicate, e as QueryASTCompoundPredicate, a as QueryASTField, l as QueryASTIncludes, p as QueryASTNodeQuery, s as QueryASTNodeQueryOptions, f as QueryASTNotPredicate, c as QueryASTOperator, h as QueryASTOrderBy, i as QueryASTPage, B as QueryASTPlannerGate, g as QueryASTPredicate, q as QueryASTQuerySet, o as QueryASTQuerySetAggregate, j as QueryASTRelationDirection, k as QueryASTRelationInclude, t as QueryASTRelationIncludeOptions, w as QueryASTRelationIndexRequirement, b as QueryASTSchemaInput, u as QueryASTValidationError, v as QueryASTValidationResult, Q as QueryASTVersion, S as SavedViewDescriptor, F as SavedViewFeedDensity, E as SavedViewFeedLayout, C as SavedViewPresentationHint, D as SavedViewPresentationHintMode, V as and, a3 as avg, N as between, P as contains, a0 as count, a1 as countDistinct, a9 as dashboardQuerySet, Z as defineNodeQueryAST, a8 as defineQuerySetAST, ab as defineSavedViewDescriptor, H as eq, aj as evaluateQueryASTPlannerGate, af as executeQueryASTLoadedAggregates, ag as filterQueryASTLoadedRows, _ as follow, $ as from, ah as getQueryASTRelationIndexRequirements, a6 as groupBy, J as gt, K as gte, a7 as having, O as includesAny, U as isNotNull, T as isNull, L as lt, M as lte, ai as matchesQueryASTLoadedRow, a5 as max, a4 as min, I as neq, X as not, W as or, ae as planQueryASTAggregates, Y as queryOperators, aa as querySetCount, R as startsWith, a2 as sum, ac as validateQueryAST, ad as validateSavedViewDescriptor } from '../query-ast-CWo6_30h.js';
+export { N as NodeStore } from '../store-CvgiydME.js';
+import { AuthAction, DID, AuthDenyReason, AuthDecision, ContentId } from '@xnetjs/core';
+import { SQLiteAdapter, SQLiteOperationStats } from '@xnetjs/sqlite';
+import '@xnetjs/crypto';
+import '@xnetjs/sync';
+
+/**
+ * Error thrown when a local mutation fails authorization checks.
+ */
+declare class PermissionError extends Error {
+    readonly code = "PERMISSION_DENIED";
+    readonly action: AuthAction;
+    readonly nodeId: string;
+    readonly subject: DID;
+    readonly reasons: AuthDenyReason[];
+    readonly roles: string[];
+    readonly decision: AuthDecision;
+    constructor(decision: AuthDecision);
+}
+
+/**
+ * In-memory storage adapter for NodeStore.
+ *
+ * Useful for testing and ephemeral data.
+ */
+
+/**
+ * In-memory implementation of NodeStorageAdapter.
+ */
+declare class MemoryNodeStorageAdapter implements NodeStorageAdapter {
+    private changes;
+    private changesByHash;
+    private nodes;
+    private documentContentStore;
+    private yjsSnapshotStore;
+    private lastLamportTime;
+    private syncCursors;
+    withTransaction<T>(fn: (storage: NodeStorageAdapter) => Promise<T>): Promise<T>;
+    appendChange(change: NodeChange): Promise<void>;
+    appendChanges(changes: readonly NodeChange[]): Promise<void>;
+    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
+    getAllChanges(): Promise<NodeChange[]>;
+    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
+    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
+    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
+    getLastChangesByNodeId(nodeIds: readonly NodeId[]): Promise<Map<NodeId, NodeChange>>;
+    getNode(id: NodeId): Promise<NodeState | null>;
+    getNodes(ids: readonly NodeId[]): Promise<NodeState[]>;
+    getExistingNodeIds(ids: readonly NodeId[]): Promise<NodeId[]>;
+    getBatchPreflight(ids: readonly NodeId[]): Promise<NodeBatchPreflightResult>;
+    setNode(node: NodeState): Promise<void>;
+    importNodes(nodes: readonly NodeState[], _options?: ImportNodesOptions): Promise<void>;
+    applyNodeBatch(input: ApplyNodeBatchInput): Promise<ApplyNodeBatchResult>;
+    deleteNode(id: NodeId): Promise<void>;
+    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
+    countNodes(options?: CountNodesOptions): Promise<number>;
+    getLastLamportTime(): Promise<number>;
+    setLastLamportTime(time: number): Promise<void>;
+    getSyncCursor(room: string): Promise<number>;
+    setSyncCursor(room: string, lamport: number): Promise<void>;
+    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
+    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
+    saveYjsSnapshot(snapshot: {
+        nodeId: NodeId;
+        timestamp: number;
+        snapshot: Uint8Array;
+        docState: Uint8Array;
+        byteSize: number;
+    }): Promise<void>;
+    getYjsSnapshots(nodeId: NodeId): Promise<{
+        nodeId: NodeId;
+        timestamp: number;
+        snapshot: Uint8Array;
+        docState: Uint8Array;
+        byteSize: number;
+    }[]>;
+    deleteYjsSnapshots(nodeId: NodeId): Promise<void>;
+    /**
+     * Clear all data (for testing).
+     */
+    clear(): void;
+    /**
+     * Get total change count (for testing).
+     */
+    getChangeCount(): number;
+    /**
+     * Get total node count (for testing).
+     */
+    getNodeCount(): number;
+    private createSnapshot;
+    private restoreSnapshot;
+}
+
+/**
+ * SQLite storage adapter for NodeStore.
+ *
+ * Provides high-performance storage for nodes and changes using SQLite.
+ * Works with any SQLiteAdapter implementation (Electron, Web, Expo).
+ */
+
+interface SQLiteAdaptiveIndexingOptions {
+    enabled?: boolean;
+    minHits?: number;
+    minDurationMs?: number;
+    minCandidates?: number;
+    maxIndexesPerSchema?: number;
+    maxEstimatedBytesPerSchema?: number;
+    maxIndexedRowsPerSchema?: number;
+    dropUnusedAfterMs?: number;
+}
+interface SQLiteQueryVerificationOptions {
+    enabled?: boolean;
+    maxNodes?: number;
+    logFailures?: boolean;
+}
+interface SQLiteNodeStorageAdapterOptions {
+    adaptiveIndexing?: SQLiteAdaptiveIndexingOptions;
+    queryVerification?: SQLiteQueryVerificationOptions;
+    /**
+     * Collect EXPLAIN QUERY PLAN + index inventory per query. Costs extra
+     * round trips per query, so it is off unless explicitly enabled or the
+     * `xnet:query:debug` localStorage flag is set.
+     */
+    queryDiagnostics?: boolean;
+}
+/**
+ * SQLite-backed storage adapter for NodeStore.
+ *
+ * This adapter provides high-performance storage for nodes and changes
+ * using the platform-appropriate SQLite implementation.
+ *
+ * @example
+ * ```typescript
+ * import { createMemorySQLiteAdapter } from '@xnetjs/sqlite/memory'
+ *
+ * const sqliteAdapter = await createMemorySQLiteAdapter()
+ * const nodeStorage = new SQLiteNodeStorageAdapter(sqliteAdapter)
+ *
+ * const store = new NodeStore({
+ *   storage: nodeStorage,
+ *   authorDID: identity.did,
+ *   signingKey: identity.signingKey
+ * })
+ * ```
+ */
+declare class SQLiteNodeStorageAdapter implements NodeStorageAdapter {
+    private db;
+    private stmtCache;
+    private adaptiveIndexing;
+    private queryVerification;
+    private queryDiagnostics;
+    private pendingQueryTelemetry;
+    private pendingQueryTelemetryHits;
+    private adaptiveIndexBudgetColumnsReady;
+    private storageCapabilitiesPromise?;
+    private spatialTablesState;
+    private fullTextSearchTablesState;
+    private writeQueue;
+    constructor(db: SQLiteAdapter, options?: SQLiteNodeStorageAdapterOptions);
+    getSQLiteAdapter(): SQLiteAdapter;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Get or create a prepared statement.
+     * Cached statements are reused for better performance.
+     */
+    private getStatement;
+    private enqueueWrite;
+    withTransaction<T>(fn: (storage: NodeStorageAdapter) => Promise<T>): Promise<T>;
+    private createTransactionStorageAdapter;
+    appendChange(change: NodeChange): Promise<void>;
+    private appendChangeInternal;
+    appendChanges(changes: readonly NodeChange[]): Promise<void>;
+    private appendChangesInternal;
+    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
+    getAllChanges(): Promise<NodeChange[]>;
+    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
+    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
+    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
+    getLastChangesByNodeId(nodeIds: readonly NodeId[]): Promise<Map<NodeId, NodeChange>>;
+    getNode(id: NodeId): Promise<NodeState | null>;
+    getNodes(ids: readonly NodeId[]): Promise<NodeState[]>;
+    getExistingNodeIds(ids: readonly NodeId[]): Promise<NodeId[]>;
+    getBatchPreflight(ids: readonly NodeId[]): Promise<NodeBatchPreflightResult>;
+    setNode(node: NodeState, options?: SetNodeOptions): Promise<void>;
+    /**
+     * Internal method for setting a node without starting a new transaction.
+     * Used by importNodes to avoid nested transactions.
+     */
+    private _setNodeInternal;
+    deleteNode(id: NodeId): Promise<void>;
+    private deleteNodeInternal;
+    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
+    /**
+     * Optimized listNodes using a single JOIN query.
+     * Fetches nodes and properties in one query for better performance with large datasets.
+     */
+    listNodesOptimized(options?: ListNodesOptions): Promise<NodeState[]>;
+    countNodes(options?: CountNodesOptions): Promise<number>;
+    queryNodes(descriptor: NodeQueryDescriptor): Promise<NodeQueryResult>;
+    getLastLamportTime(): Promise<number>;
+    setLastLamportTime(time: number): Promise<void>;
+    private setLastLamportTimeInternal;
+    private syncCursorKey;
+    getSyncCursor(room: string): Promise<number>;
+    setSyncCursor(room: string, lamport: number): Promise<void>;
+    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
+    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
+    private setDocumentContentInternal;
+    /**
+     * Save a Yjs snapshot for time travel.
+     */
+    saveYjsSnapshot(snapshot: {
+        nodeId: NodeId;
+        timestamp: number;
+        snapshot: Uint8Array;
+        docState: Uint8Array;
+        byteSize: number;
+    }): Promise<void>;
+    /**
+     * Get Yjs snapshots for a node.
+     */
+    getYjsSnapshots(nodeId: NodeId): Promise<Array<{
+        nodeId: NodeId;
+        timestamp: number;
+        snapshot: Uint8Array;
+        docState: Uint8Array;
+        byteSize: number;
+    }>>;
+    /**
+     * Delete Yjs snapshots for a node.
+     */
+    deleteYjsSnapshots(nodeId: NodeId): Promise<void>;
+    /**
+     * Import multiple nodes in a single transaction.
+     * Used for sync and restore operations.
+     */
+    importNodes(nodes: readonly NodeState[], options?: ImportNodesOptions): Promise<void>;
+    applyNodeBatch(input: ApplyNodeBatchInput): Promise<ApplyNodeBatchResult>;
+    getOperationStats(): Promise<SQLiteOperationStats | null> | SQLiteOperationStats | null;
+    resetOperationStats(): Promise<void> | void;
+    private resolveApplyNodeBatchInput;
+    private canApplyNodeBatchWithTransactionBatch;
+    private canApplyNodeBatchWithTypedAdapterCommand;
+    private applyNodeBatchWithTypedAdapterCommand;
+    private createSQLiteNodeBatchApplyInput;
+    private applyNodeBatchWithTransactionBatch;
+    private applyNodeBatchInternal;
+    private importNodesInternal;
+    private canImportNodesWithTransactionBatch;
+    private importNodesWithTransactionBatch;
+    private createImportNodeOperations;
+    private createImportNodeOperationsForIndexMode;
+    private createAppendChangeOperation;
+    private createSetLastLamportTimeOperation;
+    private createInvalidateMaterializedViewsOperation;
+    private createDeleteRemovedPropertiesOperation;
+    private createScalarIndexOperations;
+    private createFullTextIndexOperations;
+    private countScalarIndexRowsForNode;
+    private hasSearchableNodeContent;
+    private syncTouchedIndexesForNodes;
+    /**
+     * Refresh the full query-planner statistics (`ANALYZE`). Call after a bulk
+     * import: SQLite does not auto-maintain stats, so a large insert leaves the
+     * planner "out of sync" and reads can pick full scans over indexes
+     * (exploration 0184). Best-effort — never throws into the caller.
+     */
+    analyze(): Promise<void>;
+    /**
+     * Incremental planner maintenance (`PRAGMA optimize`) — only ANALYZEs tables
+     * whose row counts have drifted. Cheap; safe to call at idle / before close.
+     */
+    optimize(): Promise<void>;
+    rebuildIndexesForSchemas(schemaIds: readonly SchemaIRI[], options?: RebuildNodeIndexesOptions): Promise<void>;
+    private rebuildIndexesForSchemasInternal;
+    private rebuildScalarIndexesForSchemas;
+    private rebuildSpatialIndexesForSchemas;
+    private rebuildFullTextIndexesForSchemas;
+    /**
+     * Rebuild the scalar sidecar from materialized node_properties.
+     */
+    rebuildScalarIndex(): Promise<{
+        nodesScanned: number;
+        scalarRowsWritten: number;
+    }>;
+    /**
+     * Import multiple changes in a single transaction.
+     */
+    importChanges(changes: readonly NodeChange[]): Promise<void>;
+    /**
+     * Clear all data (for testing or reset).
+     */
+    clear(): Promise<void>;
+    private hydrateJoinedRows;
+    private hydrateNodesByIds;
+    private queryMaterializedView;
+    private getMaterializedView;
+    private refreshMaterializedView;
+    private readMaterializedViewPage;
+    private invalidateMaterializedViewsForSchema;
+    private clearMaterializedViewRows;
+    private deleteRemovedProperties;
+    private syncScalarRowsForNode;
+    private prepareFullTextSearchQueryPlan;
+    private hasFullTextSearchTable;
+    private prepareSpatialQueryPlan;
+    private ensureSpatialTables;
+    private hasSpatialTables;
+    private createSpatialIndexConfig;
+    private syncSpatialRowsForNode;
+    private replaceSpatialRowForConfig;
+    private deleteSpatialRowsForNode;
+    private deleteSpatialRow;
+    private clearSpatialRowsForConfig;
+    private clearSpatialRows;
+    private buildSpatialIndexKey;
+    private getSpatialFieldConfig;
+    private getSpatialSearchBounds;
+    private getNodeSpatialBounds;
+    private getFiniteNumberProperty;
+    private toScalarIndexValue;
+    private hashScalarValue;
+    private stringifyStable;
+    private quoteSqlLiteral;
+    private quoteSqlIdentifier;
+    private recordQueryTelemetry;
+    /**
+     * Flush buffered query telemetry aggregates into
+     * `query_descriptor_stats`. Runs automatically every
+     * {@link QUERY_TELEMETRY_FLUSH_THRESHOLD} queries and on close; callers
+     * that need durable stats immediately (tests, diagnostics tooling) can
+     * invoke it directly.
+     */
+    flushQueryTelemetry(): Promise<void>;
+    private writeQueryTelemetryRow;
+    private isQueryDiagnosticsEnabled;
+    private collectCompiledQueryDiagnostics;
+    private getStorageCapabilities;
+    private debugQueryPlan;
+    private isQueryDebugEnabled;
+    private auditQueryParity;
+    private getNodeParityCandidates;
+    private compareQueryResults;
+    private shouldCreateAdaptiveIndexes;
+    private ensureAdaptiveIndexes;
+    private ensureAdaptiveIndexBudgetColumns;
+    private estimateAdaptiveIndexBudget;
+    private getAdaptiveIndexValueBytesExpression;
+    private makeAdaptiveIndexBudgetRoom;
+    private pruneAdaptiveIndexes;
+    private getAdaptiveIndexBudgetUsage;
+    private dropLeastUsefulAdaptiveIndex;
+    private dropAdaptiveIndex;
+    private debugAdaptiveIndex;
+    private buildProtectedIndexFilter;
+    private buildAdaptiveIndexName;
+    private buildAdaptiveIndexDDL;
+    private getAdaptiveIndexColumns;
+    private countCompiledNodeQuery;
+    private compileNodeQuery;
+    private compileSqlQuery;
+    private getCompiledPostFilterReason;
+    private appendScalarPredicate;
+    private buildSqlOrderBy;
+    private hasOnlySystemOrdering;
+    private serializePayload;
+    private deserializePayload;
+    private serializeValue;
+    private deserializeValue;
+    private deserializeChange;
+}
+/**
+ * Create a SQLiteNodeStorageAdapter from an existing SQLiteAdapter.
+ * Use this when you want to share the SQLite connection with other services.
+ *
+ * @example
+ * ```typescript
+ * import { createMemorySQLiteAdapter } from '@xnetjs/sqlite/memory'
+ * import { createNodeStorageAdapter } from '@xnetjs/data'
+ *
+ * const db = await createMemorySQLiteAdapter()
+ * const storage = createNodeStorageAdapter(db)
+ * ```
+ */
+declare function createNodeStorageAdapter(db: SQLiteAdapter, options?: SQLiteNodeStorageAdapterOptions): SQLiteNodeStorageAdapter;
+
+export { ApplyNodeBatchInput, ApplyNodeBatchResult, CountNodesOptions, ImportNodesOptions, ListNodesOptions, MemoryNodeStorageAdapter, NodeBatchPreflightResult, NodeChange, NodeId, NodeQueryDescriptor, NodeQueryResult, NodeState, NodeStorageAdapter, PermissionError, RebuildNodeIndexesOptions, type SQLiteAdaptiveIndexingOptions, SQLiteNodeStorageAdapter, type SQLiteNodeStorageAdapterOptions, type SQLiteQueryVerificationOptions, SetNodeOptions, createNodeStorageAdapter };

package/dist/store/index.js

@@ -0,0 +1,135 @@
+import {
+  MemoryNodeStorageAdapter,
+  NodeStore,
+  PermissionError,
+  QUERY_AST_VERSION,
+  SQLiteNodeStorageAdapter,
+  TEMP_ID_PREFIX,
+  and,
+  avg,
+  between,
+  contains,
+  count,
+  countDistinct,
+  createNodeStorageAdapter,
+  createPropertyLookup,
+  createSchemaLookup,
+  dashboardQuerySet,
+  defineNodeQueryAST,
+  defineQuerySetAST,
+  defineSavedViewDescriptor,
+  eq,
+  evaluateQueryASTPlannerGate,
+  executeQueryASTLoadedAggregates,
+  filterQueryASTLoadedRows,
+  follow,
+  from,
+  getQueryASTRelationIndexRequirements,
+  groupBy,
+  gt,
+  gte,
+  having,
+  includesAny,
+  isNotNull,
+  isNull,
+  isTempId,
+  lt,
+  lte,
+  matchesQueryASTLoadedRow,
+  max,
+  min,
+  neq,
+  not,
+  or,
+  planQueryASTAggregates,
+  queryOperators,
+  querySetCount,
+  resolveTempIds,
+  startsWith,
+  sum,
+  validateQueryAST,
+  validateSavedViewDescriptor
+} from "../chunk-QVZXXJSP.js";
+import {
+  applyNodeQueryDescriptor,
+  createNodeQueryDescriptor,
+  decodeNodeQueryCursor,
+  encodeNodeQueryCursor,
+  filterNodeQueryResults,
+  getNodeQuerySearchTokens,
+  matchesNodeQueryDescriptor,
+  nodeQueryDescriptorNeedsBoundedReload,
+  nodeQueryDescriptorToOptions,
+  serializeNodeQueryDescriptor,
+  sortNodeQueryResults,
+  withoutNodeQueryMaterializedView,
+  withoutNodeQueryPagination
+} from "../chunk-S4B5OPZU.js";
+import "../chunk-V6HZ3LF3.js";
+import "../chunk-O64EK5FK.js";
+import "../chunk-JESSJ5CZ.js";
+export {
+  MemoryNodeStorageAdapter,
+  NodeStore,
+  PermissionError,
+  QUERY_AST_VERSION,
+  SQLiteNodeStorageAdapter,
+  TEMP_ID_PREFIX,
+  and,
+  applyNodeQueryDescriptor,
+  avg,
+  between,
+  contains,
+  count,
+  countDistinct,
+  createNodeQueryDescriptor,
+  createNodeStorageAdapter,
+  createPropertyLookup,
+  createSchemaLookup,
+  dashboardQuerySet,
+  decodeNodeQueryCursor,
+  defineNodeQueryAST,
+  defineQuerySetAST,
+  defineSavedViewDescriptor,
+  encodeNodeQueryCursor,
+  eq,
+  evaluateQueryASTPlannerGate,
+  executeQueryASTLoadedAggregates,
+  filterNodeQueryResults,
+  filterQueryASTLoadedRows,
+  follow,
+  from,
+  getNodeQuerySearchTokens,
+  getQueryASTRelationIndexRequirements,
+  groupBy,
+  gt,
+  gte,
+  having,
+  includesAny,
+  isNotNull,
+  isNull,
+  isTempId,
+  lt,
+  lte,
+  matchesNodeQueryDescriptor,
+  matchesQueryASTLoadedRow,
+  max,
+  min,
+  neq,
+  nodeQueryDescriptorNeedsBoundedReload,
+  nodeQueryDescriptorToOptions,
+  not,
+  or,
+  planQueryASTAggregates,
+  queryOperators,
+  querySetCount,
+  resolveTempIds,
+  serializeNodeQueryDescriptor,
+  sortNodeQueryResults,
+  startsWith,
+  sum,
+  validateQueryAST,
+  validateSavedViewDescriptor,
+  withoutNodeQueryMaterializedView,
+  withoutNodeQueryPagination
+};