@typicalday/firegraph 0.12.0 → 0.13.0

package/dist/types-DxYLy8Ol.d.cts

@@ -1,770 +0,0 @@
-import { WhereFilterOp, Timestamp, FieldValue } from '@google-cloud/firestore';
-
-/**
- * Firegraph Configuration — project-level config file support.
- *
- * Projects create a `firegraph.config.ts` (or `.js`/`.mjs`) in their root:
- *
- * @example
- * ```ts
- * import { defineConfig } from 'firegraph';
- *
- * export default defineConfig({
- *   entities: './entities',
- *   project: 'my-project',
- *   collection: 'graph',
- * });
- * ```
- */
-
-/** Display contexts where views can appear. */
-type ViewContext = 'listing' | 'detail' | 'inline';
-/** View resolution configuration for a single entity type. */
-interface ViewResolverConfig {
-    /** Default view name (e.g. 'card'). Falls back to 'json' if unset. */
-    default?: string;
-    /** View to use in NodeBrowser listing rows. */
-    listing?: string;
-    /** View to use on the NodeDetail page. */
-    detail?: string;
-    /** View to use for inline/embedded previews (edge rows, traversal). */
-    inline?: string;
-}
-/** Declarative view defaults, keyed by entity type. */
-interface ViewDefaultsConfig {
-    /** Node view defaults keyed by aType (e.g. 'user', 'task'). */
-    nodes?: Record<string, ViewResolverConfig>;
-    /** Edge view defaults keyed by axbType (e.g. 'hasDeparture'). */
-    edges?: Record<string, ViewResolverConfig>;
-}
-/** Project-level firegraph configuration. */
-interface FiregraphConfig {
-    /** Path to entities directory (per-entity folder convention). */
-    entities?: string;
-    /** GCP project ID. */
-    project?: string;
-    /** Firestore collection path (default: 'graph'). */
-    collection?: string;
-    /** Firestore emulator address (e.g. '127.0.0.1:8080'). */
-    emulator?: string;
-    /**
-     * Query execution backend.
-     *
-     * - `'pipeline'` (default) — Uses Firestore Pipeline API. Requires Enterprise
-     *   Firestore. Enables indexless queries on `data.*` fields.
-     * - `'standard'` — Uses standard Firestore `.where().get()` queries. Not
-     *   recommended for production. See README for risk details.
-     *
-     * When the emulator is active, always falls back to `'standard'`.
-     */
-    queryMode?: QueryMode;
-    /**
-     * AI chat configuration. Auto-detects `claude` CLI on PATH by default.
-     * Set to `false` to disable chat even if claude is available.
-     */
-    chat?: false | {
-        /** Claude model to use (default: 'sonnet'). */
-        model?: string;
-        /** Maximum concurrent claude processes (default: 2). */
-        maxConcurrency?: number;
-    };
-    /** Editor-specific settings. */
-    editor?: {
-        /** Server port (default: 3883). */
-        port?: number;
-        /** Force read-only mode. */
-        readonly?: boolean;
-    };
-    /** Declarative view defaults per entity type (overrides per-entity meta.json). */
-    viewDefaults?: ViewDefaultsConfig;
-    /**
-     * Dynamic registry mode. When set, the editor loads type definitions
-     * from Firestore meta-nodes in addition to filesystem entities.
-     * Filesystem types take precedence on name conflicts.
-     */
-    registryMode?: DynamicRegistryConfig;
-}
-/**
- * Identity function providing type-checking and autocomplete for config files.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'firegraph';
- * export default defineConfig({ entities: './entities' });
- * ```
- */
-declare function defineConfig(config: FiregraphConfig): FiregraphConfig;
-/**
- * Resolve which view to show for a given entity.
- *
- * 1. If `context` is provided and a context-specific default exists, use it.
- * 2. Falls back to `resolverConfig.default`.
- * 3. Ultimate fallback: `'json'`.
- *
- * Only returns view names that exist in `availableViewNames`.
- */
-declare function resolveView(resolverConfig: ViewResolverConfig | undefined, availableViewNames: string[], context?: ViewContext): string;
-
-/**
- * Backend-agnostic timestamp.
- *
- * Structurally compatible with `@google-cloud/firestore`'s `Timestamp` so
- * that records returned by either the Firestore or SQLite backend can be
- * consumed through the same `StoredGraphRecord` shape.
- *
- * Firestore's native `Timestamp` already satisfies this interface, so
- * existing Firestore consumers see no behavior change. The SQLite backend
- * returns instances of `GraphTimestampImpl` which also satisfies it.
- */
-interface GraphTimestamp {
-    readonly seconds: number;
-    readonly nanoseconds: number;
-    toDate(): Date;
-    toMillis(): number;
-}
-
-interface GraphRecord {
-    aType: string;
-    aUid: string;
-    axbType: string;
-    bType: string;
-    bUid: string;
-    data: Record<string, unknown>;
-    createdAt: Timestamp | FieldValue;
-    updatedAt: Timestamp | FieldValue;
-    /** Schema version — set automatically when the registry entry has migrations. */
-    v?: number;
-}
-interface StoredGraphRecord {
-    aType: string;
-    aUid: string;
-    axbType: string;
-    bType: string;
-    bUid: string;
-    data: Record<string, unknown>;
-    /**
-     * Backend-agnostic timestamp. Firestore returns its native `Timestamp`
-     * (which structurally satisfies `GraphTimestamp`); the SQLite backends
-     * return a `GraphTimestampImpl` instance.
-     */
-    createdAt: GraphTimestamp;
-    updatedAt: GraphTimestamp;
-    /** Schema version — set automatically when the registry entry has migrations. */
-    v?: number;
-}
-interface WhereClause {
-    field: string;
-    op: '==' | '!=' | '<' | '<=' | '>' | '>=';
-    value: unknown;
-}
-interface FindEdgesParams {
-    aType?: string;
-    aUid?: string;
-    axbType?: string;
-    bType?: string;
-    bUid?: string;
-    limit?: number;
-    orderBy?: {
-        field: string;
-        direction?: 'asc' | 'desc';
-    };
-    where?: WhereClause[];
-    /** Set to true to allow queries that may cause full collection scans. */
-    allowCollectionScan?: boolean;
-}
-interface FindNodesParams {
-    aType: string;
-    limit?: number;
-    orderBy?: {
-        field: string;
-        direction?: 'asc' | 'desc';
-    };
-    where?: WhereClause[];
-    /** Set to true to allow queries that may cause full collection scans. */
-    allowCollectionScan?: boolean;
-}
-interface QueryOptions {
-    limit?: number;
-    orderBy?: {
-        field: string;
-        direction?: 'asc' | 'desc';
-    };
-}
-type QueryPlan = {
-    strategy: 'get';
-    docId: string;
-} | {
-    strategy: 'query';
-    filters: QueryFilter[];
-    options?: QueryOptions;
-};
-interface QueryFilter {
-    field: string;
-    op: WhereFilterOp;
-    value: unknown;
-}
-/**
- * An executable migration function that transforms data from one schema
- * version to the next. Can be synchronous or asynchronous.
- */
-type MigrationFn = (data: Record<string, unknown>) => Record<string, unknown> | Promise<Record<string, unknown>>;
-/**
- * A single migration step in a registry entry.
- * Transforms data from `fromVersion` to `toVersion`.
- */
-interface MigrationStep {
-    fromVersion: number;
-    toVersion: number;
-    up: MigrationFn;
-}
-/**
- * A stored migration step for dynamic registry types.
- * The `up` field is a source code string that will be compiled at runtime.
- *
- * @example
- * ```ts
- * { fromVersion: 0, toVersion: 1, up: "(data) => ({ ...data, status: 'draft' })" }
- * ```
- */
-interface StoredMigrationStep {
-    fromVersion: number;
-    toVersion: number;
-    up: string;
-}
-/**
- * Pluggable executor interface for compiling migration function source
- * strings into executable functions. Used for dynamic registry migrations.
- *
- * The default executor uses SES (Secure ECMAScript) Compartments with
- * JSON marshaling for isolation. Users can supply an alternative via
- * `GraphClientOptions.migrationSandbox`.
- */
-type MigrationExecutor = (source: string) => MigrationFn;
-/** Write-back mode for auto-migrated records. */
-type MigrationWriteBack = 'off' | 'eager' | 'background';
-/**
- * One field in a composite index. The string shorthand form defaults to
- * ascending order; use the object form when a field needs to be indexed
- * descending (e.g., pagination by `{ path: 'updatedAt', desc: true }`).
- */
-interface IndexFieldSpec {
-    /**
-     * Field path. Top-level firegraph fields (`aType`, `aUid`, `axbType`,
-     * `bType`, `bUid`, `createdAt`, `updatedAt`, `v`) resolve to their
-     * underlying columns. Dotted paths like `'data.status'` or
-     * `'data.author.name'` index into the JSON data payload.
-     *
-     * Each dotted component must match `/^[A-Za-z_][A-Za-z0-9_-]*$/` — keys
-     * with dots, quotes, brackets, spaces, or other syntax characters are
-     * rejected at DDL build time. Indexes on exotic keys are not supported
-     * because SQLite expression indexes must match the query compiler's
-     * output verbatim, and inlining quoted path components into DDL would
-     * desynchronize the two compilers. If you need to filter by an exotic
-     * key, use `replaceNode` / `replaceEdge` writes rather than an indexed
-     * field.
-     */
-    path: string;
-    /** Descending order; defaults to ascending. */
-    desc?: boolean;
-}
-/**
- * Declarative secondary index. Translators emit a `CREATE INDEX` statement
- * (SQLite) or a `FirestoreIndex` composite (Firestore) per spec.
- *
- * Composite indexes support the prefix of their `fields` list — a spec
- * `{ fields: ['aType', 'axbType'] }` also covers queries filtering on
- * `aType` alone.
- *
- * @example
- * ```ts
- * // Plain composite on top-level fields
- * { fields: ['aType', 'axbType'] }
- *
- * // Mixed string + object form; `updatedAt` descending
- * { fields: ['aType', 'aUid', 'axbType', { path: 'updatedAt', desc: true }] }
- *
- * // JSON data-field index (SQLite: expression index on json_extract)
- * { fields: ['aType', 'axbType', 'data.status'] }
- *
- * // Partial index (SQLite only — Firestore ignores the `where` clause)
- * { fields: ['aType'], where: "json_extract(data, '$.archived') = 0" }
- * ```
- */
-interface IndexSpec {
-    /**
-     * Ordered field list. String shorthand = ascending. Use `IndexFieldSpec`
-     * form to mark individual fields descending.
-     */
-    fields: Array<string | IndexFieldSpec>;
-    /**
-     * Partial-index predicate. Applied verbatim after `WHERE` in the emitted
-     * SQLite DDL. Ignored (with a one-time warning) by the Firestore
-     * generator — Firestore composite indexes do not support predicates.
-     */
-    where?: string;
-}
-interface RegistryEntry {
-    aType: string;
-    axbType: string;
-    bType: string;
-    /** JSON Schema object for the data payload. */
-    jsonSchema?: object;
-    description?: string;
-    inverseLabel?: string;
-    /** Data field to use as the display title (e.g. 'name', 'date'). */
-    titleField?: string;
-    /** Data field to use as the display subtitle (e.g. 'status', 'difficulty'). */
-    subtitleField?: string;
-    /**
-     * Scope patterns constraining where this type can exist.
-     * Omit or leave empty to allow everywhere (backwards compatible).
-     *
-     * Patterns:
-     *   - `'root'`            — top-level collection only
-     *   - `'agents'`          — exact subgraph name match
-     *   - `'workflow/agents'`  — exact path match
-     *   - `'*​/agents'`        — `*` matches one segment
-     *   - `'**​/agents'`       — `**` matches zero or more segments
-     */
-    allowedIn?: string[];
-    /**
-     * Subgraph name where cross-graph edges of this type live.
-     *
-     * When set, forward traversal queries the named subgraph under each
-     * source node (e.g., `{collection}/{sourceUid}/{targetGraph}`) instead
-     * of the current collection. The subgraph contains both the edge
-     * documents and the target nodes they reference.
-     *
-     * Reverse traversal is unaffected — if you're already in the subgraph,
-     * the edges are local.
-     *
-     * Only applies to edge entries (not node self-loop entries).
-     * Must be a single segment (no `/`).
-     *
-     * @example
-     * ```ts
-     * { aType: 'task', axbType: 'assignedTo', bType: 'agent', targetGraph: 'workflow' }
-     * // Forward traversal from task1: queries {collection}/task1/workflow
-     * ```
-     */
-    targetGraph?: string;
-    /**
-     * Schema version for this type's data payload.
-     * **Computed automatically** from `migrations` as `max(toVersion)`.
-     * Do not set directly — provide migrations instead.
-     */
-    schemaVersion?: number;
-    /**
-     * Ordered list of migrations to transform data from older versions
-     * to the current version. The schema version is derived as the highest
-     * `toVersion` in this array.
-     */
-    migrations?: MigrationStep[];
-    /**
-     * Per-entry write-back override for auto-migrated records.
-     * Takes precedence over `GraphClientOptions.migrationWriteBack`.
-     * Omit to inherit the global setting.
-     */
-    migrationWriteBack?: MigrationWriteBack;
-    /**
-     * Secondary indexes tied to this triple. Each spec becomes a single
-     * backend-native composite index scoped to rows matching
-     * `(aType, axbType, bType)` — though the DDL does not currently restrict
-     * by triple, so authors should think of these as globally-applied indexes
-     * declared on the triple's behalf.
-     *
-     * Use this to accelerate `findNodes` / `findEdges` queries that filter
-     * on `data.*` fields or compose with firegraph's top-level fields in ways
-     * the default preset doesn't cover.
-     */
-    indexes?: IndexSpec[];
-}
-/** Topology declaration for an edge (from edge.json). */
-interface EdgeTopology {
-    from: string | string[];
-    to: string | string[];
-    inverseLabel?: string;
-    /**
-     * Subgraph name where cross-graph edges of this type live.
-     * See `RegistryEntry.targetGraph` for full documentation.
-     */
-    targetGraph?: string;
-}
-/** A discovered entity from the per-entity folder convention. */
-interface DiscoveredEntity {
-    kind: 'node' | 'edge';
-    name: string;
-    /** Parsed JSON Schema for the data payload. */
-    schema: object;
-    /** Edge topology (only for edges). */
-    topology?: EdgeTopology;
-    description?: string;
-    /** Data field to use as the display title (e.g. 'name', 'date'). */
-    titleField?: string;
-    /** Data field to use as the display subtitle (e.g. 'status', 'difficulty'). */
-    subtitleField?: string;
-    /** View defaults from meta.json. */
-    viewDefaults?: ViewResolverConfig;
-    /** Absolute path to views.ts if present. */
-    viewsPath?: string;
-    /** Sample data from sample.json. */
-    sampleData?: Record<string, unknown>;
-    /** Scope patterns constraining where this type can exist in subgraphs. */
-    allowedIn?: string[];
-    /** Subgraph name where cross-graph edges of this type live. */
-    targetGraph?: string;
-    /** Migration steps loaded from migrations.ts. */
-    migrations?: MigrationStep[];
-    /** Per-entity write-back override from meta.json. */
-    migrationWriteBack?: MigrationWriteBack;
-    /** Secondary indexes loaded from meta.json (`indexes` field). */
-    indexes?: IndexSpec[];
-}
-/** Result of scanning an entities directory. */
-interface DiscoveryResult {
-    nodes: Map<string, DiscoveredEntity>;
-    edges: Map<string, DiscoveredEntity>;
-}
-/** Controls which Firestore query backend is used. */
-type QueryMode = 'pipeline' | 'standard';
-/**
- * Configuration for dynamic registry mode where type definitions
- * are stored as graph data (meta-nodes) rather than in code.
- */
-interface DynamicRegistryConfig {
-    mode: 'dynamic';
-    /**
-     * Collection path for meta-type nodes (`nodeType`, `edgeType`).
-     * Defaults to the main `collectionPath` if omitted.
-     */
-    collection?: string;
-}
-/** Options for defineNodeType / defineEdgeType beyond the core fields. */
-interface DefineTypeOptions {
-    /** Data field to use as the display title (e.g. 'name', 'date'). */
-    titleField?: string;
-    /** Data field to use as the display subtitle (e.g. 'status', 'difficulty'). */
-    subtitleField?: string;
-    /** Mustache HTML template for rendering this type in the editor. */
-    viewTemplate?: string;
-    /** Scoped CSS for the view template (injected via Shadow DOM). */
-    viewCss?: string;
-    /** Scope patterns constraining where this type can exist in subgraphs. */
-    allowedIn?: string[];
-    /**
-     * Migration steps. Accepts function objects (auto-serialized via .toString())
-     * or strings (stored as-is). The schema version is derived as the highest
-     * `toVersion` in this array.
-     */
-    migrations?: Array<{
-        fromVersion: number;
-        toVersion: number;
-        up: MigrationFn | string;
-    }>;
-    /** Per-type write-back override for auto-migrated records. */
-    migrationWriteBack?: MigrationWriteBack;
-}
-/** Data shape stored in a `nodeType` meta-node. */
-interface NodeTypeData {
-    name: string;
-    jsonSchema: object;
-    description?: string;
-    titleField?: string;
-    subtitleField?: string;
-    viewTemplate?: string;
-    viewCss?: string;
-    allowedIn?: string[];
-    migrations?: StoredMigrationStep[];
-    migrationWriteBack?: MigrationWriteBack;
-}
-/** Data shape stored in an `edgeType` meta-node. */
-interface EdgeTypeData {
-    name: string;
-    from: string | string[];
-    to: string | string[];
-    jsonSchema?: object;
-    inverseLabel?: string;
-    description?: string;
-    titleField?: string;
-    subtitleField?: string;
-    viewTemplate?: string;
-    viewCss?: string;
-    allowedIn?: string[];
-    targetGraph?: string;
-    migrations?: StoredMigrationStep[];
-    migrationWriteBack?: MigrationWriteBack;
-}
-type ScanProtection = 'error' | 'warn' | 'off';
-interface GraphClientOptions {
-    /**
-     * Static registry built from code/discovery.
-     *
-     * When provided alone, all writes are validated against this registry.
-     *
-     * When provided together with `registryMode`, operates in **merged mode**:
-     * static entries take priority and cannot be overridden by dynamic
-     * definitions. Dynamic definitions can only add new types. The merged
-     * client is returned as a `DynamicGraphClient`.
-     */
-    registry?: GraphRegistry;
-    /** Dynamic registry mode — type definitions stored as graph data. */
-    registryMode?: DynamicRegistryConfig;
-    /**
-     * Query execution backend.
-     *
-     * - `'pipeline'` (default) — Uses Firestore Pipeline API. Requires Enterprise
-     *   Firestore. Enables indexless queries on `data.*` fields.
-     * - `'standard'` — Uses standard Firestore `.where().get()` queries. Requires
-     *   composite indexes for `data.*` filters or risks full collection scans
-     *   (Enterprise) / query failures (Standard Firestore).
-     *
-     * When `FIRESTORE_EMULATOR_HOST` is set, the client auto-falls back to
-     * `'standard'` regardless of this setting (emulator doesn't support pipelines).
-     */
-    queryMode?: QueryMode;
-    /**
-     * Controls query safety behavior for full collection scan prevention.
-     *
-     * - `'error'` (default) — Throws `QuerySafetyError` for queries that would
-     *   likely cause a full collection scan. Override per-query with
-     *   `allowCollectionScan: true`.
-     * - `'warn'` — Logs a warning but executes the query.
-     * - `'off'` — No scan protection.
-     */
-    scanProtection?: ScanProtection;
-    /**
-     * Global default for write-back of auto-migrated records on read.
-     *
-     * - `'off'` (default) — Migrated data is returned but NOT written back.
-     * - `'eager'` — Migrated data is written back immediately after migration.
-     * - `'background'` — Write-back happens asynchronously; errors are logged.
-     *
-     * Per-entry `migrationWriteBack` on `RegistryEntry` overrides this setting.
-     */
-    migrationWriteBack?: MigrationWriteBack;
-    /**
-     * Custom executor for compiling dynamic registry migration source strings.
-     * Defaults to SES Compartments with JSON marshaling. Supply an
-     * alternative for custom sandboxing.
-     *
-     * Only used for dynamic registry migrations — static registry migrations
-     * are already in-memory functions and never go through this executor.
-     */
-    migrationSandbox?: MigrationExecutor;
-}
-interface GraphRegistry {
-    validate(aType: string, axbType: string, bType: string, data: unknown, scopePath?: string): void;
-    lookup(aType: string, axbType: string, bType: string): RegistryEntry | undefined;
-    /** Return all entries matching the given axbType (edge relation name). */
-    lookupByAxbType(axbType: string): ReadonlyArray<RegistryEntry>;
-    /**
-     * Return every edge entry originating from `aType` that has `targetGraph`
-     * set — i.e. the direct subgraph children of nodes of this type.
-     *
-     * Used by backends that need to enumerate a node's subgraph DOs without
-     * walking the graph. Each returned entry carries both `axbType` (the edge
-     * label that introduces the subgraph) and `targetGraph` (the subgraph
-     * segment name).
-     *
-     * Entries are deduplicated by `targetGraph` alone — the physical subgraph
-     * store is addressed by `(parentUid, targetGraph)`, so multiple edge
-     * relations (distinct `axbType` or `bType`) pointing into the same segment
-     * collapse to a single representative entry. The first-declared entry
-     * wins the collision. Callers only care about the subgraph name, not the
-     * originating relation or target node type.
-     */
-    getSubgraphTopology(aType: string): ReadonlyArray<RegistryEntry>;
-    entries(): ReadonlyArray<RegistryEntry>;
-}
-interface GraphReader {
-    getNode(uid: string): Promise<StoredGraphRecord | null>;
-    getEdge(aUid: string, axbType: string, bUid: string): Promise<StoredGraphRecord | null>;
-    edgeExists(aUid: string, axbType: string, bUid: string): Promise<boolean>;
-    findEdges(params: FindEdgesParams): Promise<StoredGraphRecord[]>;
-    findNodes(params: FindNodesParams): Promise<StoredGraphRecord[]>;
-}
-interface GraphWriter {
-    /**
-     * Write a node, deep-merging into any existing record.
-     *
-     * Nested objects are merged recursively — sibling keys at any depth
-     * survive. Arrays are terminal (replaced as a unit, not element-merged).
-     * `undefined` values are omitted; `null` is preserved. To delete a field,
-     * pass the `deleteField()` sentinel as its value.
-     *
-     * Use {@link replaceNode} when you want full-document replacement.
-     */
-    putNode(aType: string, uid: string, data: Record<string, unknown>): Promise<void>;
-    /**
-     * Write an edge, deep-merging into any existing record. See
-     * {@link putNode} for the merge contract.
-     */
-    putEdge(aType: string, aUid: string, axbType: string, bType: string, bUid: string, data: Record<string, unknown>): Promise<void>;
-    /**
-     * Replace a node's `data` payload entirely. Any field absent from
-     * `data` is dropped. Use sparingly — prefer {@link putNode} unless you
-     * specifically need to drop unknown fields.
-     */
-    replaceNode(aType: string, uid: string, data: Record<string, unknown>): Promise<void>;
-    /**
-     * Replace an edge's `data` payload entirely. See {@link replaceNode}.
-     */
-    replaceEdge(aType: string, aUid: string, axbType: string, bType: string, bUid: string, data: Record<string, unknown>): Promise<void>;
-    /**
-     * Patch a node's `data` payload. Like {@link putNode} this is a deep
-     * merge — nested objects are walked, only leaves are written. Use the
-     * `deleteField()` sentinel to remove a field.
-     */
-    updateNode(uid: string, data: Record<string, unknown>): Promise<void>;
-    /**
-     * Patch an edge's `data` payload. See {@link updateNode}.
-     */
-    updateEdge(aUid: string, axbType: string, bUid: string, data: Record<string, unknown>): Promise<void>;
-    removeNode(uid: string): Promise<void>;
-    removeEdge(aUid: string, axbType: string, bUid: string): Promise<void>;
-}
-interface GraphClient extends GraphReader, GraphWriter {
-    runTransaction<T>(fn: (tx: GraphTransaction) => Promise<T>): Promise<T>;
-    batch(): GraphBatch;
-    /** Delete a node and all its outgoing/incoming edges in chunked batches. */
-    removeNodeCascade(uid: string, options?: BulkOptions): Promise<CascadeResult>;
-    /** Find all edges matching `params` and delete them in chunked batches. */
-    bulkRemoveEdges(params: FindEdgesParams, options?: BulkOptions): Promise<BulkResult>;
-    /**
-     * Create a scoped client for a Firestore subcollection under the given
-     * parent node's document.
-     *
-     * The returned client shares a snapshot of the parent's registry at
-     * the time of this call. If the parent is a `DynamicGraphClient` and
-     * `reloadRegistry()` is called later, existing subgraph clients will
-     * NOT see the updated types — create a new subgraph client after
-     * reloading to pick up changes.
-     *
-     * @param parentNodeUid - UID of the parent node whose document owns the subcollection
-     * @param name - Subcollection name (defaults to `'graph'`). Must not contain `/`.
-     * @returns A `GraphClient` scoped to `{collectionPath}/{parentNodeUid}/{name}`
-     */
-    subgraph(parentNodeUid: string, name?: string): GraphClient;
-    /**
-     * Find edges across all subgraphs using a Firestore collection group query.
-     *
-     * Queries all collections with the given name (defaults to `'graph'`) across
-     * the entire database. This is useful for cross-cutting reads that span
-     * multiple subgraphs.
-     *
-     * **Requires** a Firestore collection group index for the query pattern.
-     *
-     * @param params - Edge filter parameters (same as `findEdges`)
-     * @param collectionName - Collection name to query across (defaults to last segment of this client's collection path)
-     */
-    findEdgesGlobal(params: FindEdgesParams, collectionName?: string): Promise<StoredGraphRecord[]>;
-}
-interface DynamicGraphClient extends GraphClient {
-    /** Define or update a node type in the dynamic registry. */
-    defineNodeType(name: string, jsonSchema: object, description?: string, options?: DefineTypeOptions): Promise<void>;
-    /** Define or update an edge type in the dynamic registry. */
-    defineEdgeType(name: string, topology: EdgeTopology, jsonSchema?: object, description?: string, options?: DefineTypeOptions): Promise<void>;
-    /** Reload the registry from meta-type nodes in the graph. */
-    reloadRegistry(): Promise<void>;
-}
-interface GraphTransaction extends GraphReader, GraphWriter {
-}
-interface GraphBatch extends GraphWriter {
-    commit(): Promise<void>;
-}
-interface HopDefinition {
-    axbType: string;
-    direction?: 'forward' | 'reverse';
-    aType?: string;
-    bType?: string;
-    limit?: number;
-    orderBy?: {
-        field: string;
-        direction?: 'asc' | 'desc';
-    };
-    filter?: (edge: StoredGraphRecord) => boolean;
-    /**
-     * Subgraph name to cross into for this hop (forward traversal only).
-     *
-     * When set, the traversal queries the named subgraph under each source node
-     * instead of the current collection (`{collection}/{sourceUid}/{targetGraph}`).
-     *
-     * If omitted but the registry has a `targetGraph` for this `axbType`,
-     * the registry value is used automatically.
-     *
-     * **Context tracking:** Once a hop crosses into a subgraph, subsequent
-     * hops without `targetGraph` stay in that subgraph automatically. To
-     * cross into a different subgraph, set `targetGraph` explicitly on the
-     * next hop — explicit `targetGraph` always resolves relative to the
-     * root client, not the current subgraph. To return to the root graph,
-     * create a separate traversal from the root client.
-     */
-    targetGraph?: string;
-}
-interface TraversalOptions {
-    maxReads?: number;
-    concurrency?: number;
-    returnIntermediates?: boolean;
-}
-interface HopResult {
-    axbType: string;
-    depth: number;
-    edges: StoredGraphRecord[];
-    sourceCount: number;
-    truncated: boolean;
-}
-interface TraversalResult {
-    nodes: StoredGraphRecord[];
-    hops: HopResult[];
-    totalReads: number;
-    truncated: boolean;
-}
-interface TraversalBuilder {
-    follow(axbType: string, options?: Omit<HopDefinition, 'axbType'>): TraversalBuilder;
-    run(options?: TraversalOptions): Promise<TraversalResult>;
-}
-interface BulkOptions {
-    /** Max operations per Firestore batch (default 500, Firestore hard limit). */
-    batchSize?: number;
-    /** Number of retry attempts per failed batch (default 3). */
-    maxRetries?: number;
-    /** Called after each batch commits. */
-    onProgress?: (progress: BulkProgress) => void;
-    /**
-     * Recursively delete subcollections (subgraphs) under the node's document.
-     * Defaults to `true` for `removeNodeCascade`.
-     */
-    deleteSubcollections?: boolean;
-}
-interface BulkProgress {
-    /** Batches committed so far. */
-    completedBatches: number;
-    /** Total batches planned. */
-    totalBatches: number;
-    /** Total documents deleted so far. */
-    deletedSoFar: number;
-}
-interface BulkResult {
-    /** Total documents successfully deleted. */
-    deleted: number;
-    /** Number of batches committed. */
-    batches: number;
-    /** Errors from batches that failed after all retries. */
-    errors: BulkBatchError[];
-}
-interface BulkBatchError {
-    /** Zero-based index of the failed batch. */
-    batchIndex: number;
-    /** The underlying error. */
-    error: Error;
-    /** Number of operations in this batch that were not applied. */
-    operationCount: number;
-}
-interface CascadeResult extends BulkResult {
-    /** Number of edges deleted. */
-    edgesDeleted: number;
-    /** Whether the node itself was deleted. */
-    nodeDeleted: boolean;
-}
-
-export { type ScanProtection as A, type BulkBatchError as B, type CascadeResult as C, type DynamicGraphClient as D, type EdgeTopology as E, type FindEdgesParams as F, type GraphClientOptions as G, type HopDefinition as H, type IndexSpec as I, type TraversalOptions as J, type TraversalResult as K, type ViewDefaultsConfig as L, type MigrationWriteBack as M, type NodeTypeData as N, type ViewResolverConfig as O, defineConfig as P, type QueryPlan as Q, type RegistryEntry as R, type StoredGraphRecord as S, type TraversalBuilder as T, resolveView as U, type ViewContext as V, type WhereClause as W, type GraphClient as a, type DiscoveryResult as b, type DynamicRegistryConfig as c, type MigrationStep as d, type GraphRegistry as e, type FindNodesParams as f, type QueryFilter as g, type GraphRecord as h, type MigrationExecutor as i, type MigrationFn as j, type StoredMigrationStep as k, type GraphReader as l, type BulkOptions as m, type BulkProgress as n, type BulkResult as o, type DefineTypeOptions as p, type DiscoveredEntity as q, type EdgeTypeData as r, type FiregraphConfig as s, type GraphBatch as t, type GraphTransaction as u, type GraphWriter as v, type HopResult as w, type IndexFieldSpec as x, type QueryMode as y, type QueryOptions as z };