@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/interchange/index.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
-import { G as GraphDef } from '../manager-C0_r0ALf.js';
-import { S as Store } from '../store-view-FfE5_7eo.js';
-import '../extension-types-YGFJPrzK.js';
-import '../types-DGylBhWo.js';
+import { G as GraphDef } from '../manager-ejUCB52T.js';
+import { S as Store } from '../store-view-CKbHFRnn.js';
+import '../extension-types-ixRpJVUp.js';
+import '../fulltext-strategy-B57yvC5Q.js';
 import 'drizzle-orm';
 import 'drizzle-orm/pg-core';
 import 'drizzle-orm/sqlite-core';
-import '../materialize-indexes-CAkIYFV-.js';
+import '../materialize-indexes-te9TPMMJ.js';
 
 /**
  * Graph interchange format types.
@@ -33,7 +33,7 @@ declare const InterchangeNodeSchema: z.ZodObject<{
     kind: z.ZodString;
     id: z.ZodString;
     properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    validFrom: z.ZodOptional<z.ZodISODateTime>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     validTo: z.ZodOptional<z.ZodISODateTime>;
     meta: z.ZodOptional<z.ZodObject<{
         version: z.ZodOptional<z.ZodNumber>;
@@ -60,7 +60,7 @@ declare const InterchangeEdgeSchema: z.ZodObject<{
         id: z.ZodString;
     }, z.core.$strip>;
     properties: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    validFrom: z.ZodOptional<z.ZodISODateTime>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     validTo: z.ZodOptional<z.ZodISODateTime>;
     meta: z.ZodOptional<z.ZodObject<{
         createdAt: z.ZodOptional<z.ZodISODateTime>;
@@ -110,8 +110,18 @@ declare const ImportOptionsSchema: z.ZodObject<{
     }>>;
     validateReferences: z.ZodDefault<z.ZodBoolean>;
     batchSize: z.ZodDefault<z.ZodNumber>;
+    refreshStatistics: z.ZodOptional<z.ZodBoolean>;
+    onStreamChunkError: z.ZodDefault<z.ZodEnum<{
+        abort: "abort";
+        continue: "continue";
+    }>>;
 }, z.core.$strip>;
-type ImportOptions = z.infer<typeof ImportOptionsSchema>;
+/**
+ * Caller-facing options: fields with schema defaults are optional.
+ * `importGraph` parses these once at its boundary; internal stages
+ * consume {@link ResolvedImportOptions} with every default applied.
+ */
+type ImportOptions = z.input<typeof ImportOptionsSchema>;
 /**
  * Source metadata for graph data.
  *
@@ -149,7 +159,7 @@ declare const GraphDataSchema: z.ZodObject<{
         kind: z.ZodString;
         id: z.ZodString;
         properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        validFrom: z.ZodOptional<z.ZodISODateTime>;
+        validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
         validTo: z.ZodOptional<z.ZodISODateTime>;
         meta: z.ZodOptional<z.ZodObject<{
             version: z.ZodOptional<z.ZodNumber>;
@@ -169,7 +179,7 @@ declare const GraphDataSchema: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
         properties: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        validFrom: z.ZodOptional<z.ZodISODateTime>;
+        validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
         validTo: z.ZodOptional<z.ZodISODateTime>;
         meta: z.ZodOptional<z.ZodObject<{
             createdAt: z.ZodOptional<z.ZodISODateTime>;
@@ -178,6 +188,76 @@ declare const GraphDataSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type GraphData = z.infer<typeof GraphDataSchema>;
+/** The metadata envelope emitted before streamed graph entities. */
+declare const GraphDataHeaderSchema: z.ZodObject<{
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"typegraph-export">;
+        graphId: z.ZodString;
+        schemaVersion: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"external">;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    formatVersion: z.ZodLiteral<"1.0">;
+    exportedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type GraphDataHeader = z.infer<typeof GraphDataHeaderSchema>;
+/**
+ * One bounded unit in the streamed interchange protocol. Nodes always precede
+ * edges, so an importer can validate endpoints from rows already written to its
+ * target without retaining all prior nodes in memory.
+ */
+declare const GraphInterchangeChunkSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"header">;
+    header: z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"typegraph-export">;
+            graphId: z.ZodString;
+            schemaVersion: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"external">;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">;
+        formatVersion: z.ZodLiteral<"1.0">;
+        exportedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"nodes">;
+    nodes: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        validTo: z.ZodOptional<z.ZodISODateTime>;
+        meta: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodNumber>;
+            createdAt: z.ZodOptional<z.ZodISODateTime>;
+            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"edges">;
+    edges: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        from: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        properties: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        validFrom: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        validTo: z.ZodOptional<z.ZodISODateTime>;
+        meta: z.ZodOptional<z.ZodObject<{
+            createdAt: z.ZodOptional<z.ZodISODateTime>;
+            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+type GraphInterchangeChunk = z.infer<typeof GraphInterchangeChunkSchema>;
 /**
  * An error that occurred during import.
  */
@@ -233,6 +313,20 @@ declare const ExportOptionsSchema: z.ZodObject<{
 type ExportOptions = z.infer<typeof ExportOptionsSchema>;
 /** Export options as accepted by exportGraph (input type with optional defaults) */
 type ExportOptionsInput = z.input<typeof ExportOptionsSchema>;
+/**
+ * Export options for {@link exportGraphStream}. `batchSize` bounds the number
+ * of node or edge entities retained for one yielded chunk.
+ */
+declare const ExportStreamOptionsSchema: z.ZodObject<{
+    nodeKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    edgeKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    includeTemporal: z.ZodDefault<z.ZodBoolean>;
+    includeMeta: z.ZodDefault<z.ZodBoolean>;
+    includeDeleted: z.ZodDefault<z.ZodBoolean>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ExportStreamOptions = z.infer<typeof ExportStreamOptionsSchema>;
+type ExportStreamOptionsInput = z.input<typeof ExportStreamOptionsSchema>;
 
 /**
  * Export graph data from a store.
@@ -253,6 +347,13 @@ type ExportOptionsInput = z.input<typeof ExportOptionsSchema>;
  * ```
  */
 declare function exportGraph<G extends GraphDef>(store: Store<G>, options?: ExportOptionsInput): Promise<GraphData>;
+/**
+ * Exports a graph as bounded node and edge chunks. The stream always yields one
+ * header, then every node chunk, then every edge chunk. Consumers that write to
+ * a network, file, or fresh working copy can process one chunk at a time rather
+ * than materializing a graph-sized {@link GraphData} value.
+ */
+declare function exportGraphStream<G extends GraphDef>(store: Store<G>, options?: ExportStreamOptionsInput): AsyncIterable<GraphInterchangeChunk>;
 
 /**
  * Import graph data into a store.
@@ -275,6 +376,19 @@ declare function exportGraph<G extends GraphDef>(store: Store<G>, options?: Expo
  * console.log(`Created ${result.nodes.created} nodes`);
  * ```
  */
-declare function importGraph<G extends GraphDef>(store: Store<G>, data: GraphData, options: ImportOptions): Promise<ImportResult>;
+declare function importGraph<G extends GraphDef>(store: Store<G>, data: GraphData, rawOptions: ImportOptions): Promise<ImportResult>;
+/**
+ * Imports a header-first stream of bounded interchange chunks.
+ *
+ * Each chunk is committed through the same {@link importGraph} implementation
+ * as an in-memory import, so validation and conflict semantics stay identical.
+ * Chunks are individually atomic on transactional backends; a consumer needing
+ * all-or-nothing behavior can import into a disposable working-copy backend and
+ * publish it only after this function succeeds.
+ *
+ * Nodes must precede edges. Once a node chunk commits, edge validation reads the
+ * target store rather than retaining every imported node id in memory.
+ */
+declare function importGraphStream<G extends GraphDef>(store: Store<G>, chunks: AsyncIterable<GraphInterchangeChunk>, rawOptions: ImportOptions): Promise<ImportResult>;
 
-export { type ConflictStrategy, ConflictStrategySchema, type ExportOptions, type ExportOptionsInput, ExportOptionsSchema, FORMAT_VERSION, type GraphData, GraphDataSchema, type GraphDataSource, GraphDataSourceSchema, type ImportError, ImportErrorSchema, type ImportOptions, ImportOptionsSchema, type ImportResult, ImportResultSchema, type InterchangeEdge, InterchangeEdgeSchema, type InterchangeNode, InterchangeNodeSchema, type UnknownPropertyStrategy, UnknownPropertyStrategySchema, exportGraph, importGraph };
+export { type ConflictStrategy, ConflictStrategySchema, type ExportOptions, type ExportOptionsInput, ExportOptionsSchema, type ExportStreamOptions, type ExportStreamOptionsInput, ExportStreamOptionsSchema, FORMAT_VERSION, type GraphData, type GraphDataHeader, GraphDataHeaderSchema, GraphDataSchema, type GraphDataSource, GraphDataSourceSchema, type GraphInterchangeChunk, GraphInterchangeChunkSchema, type ImportError, ImportErrorSchema, type ImportOptions, ImportOptionsSchema, type ImportResult, ImportResultSchema, type InterchangeEdge, InterchangeEdgeSchema, type InterchangeNode, InterchangeNodeSchema, type UnknownPropertyStrategy, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream };

package/dist/interchange/index.js

@@ -1,6 +1,16 @@
-export { ConflictStrategySchema, ExportOptionsSchema, FORMAT_VERSION, GraphDataSchema, GraphDataSourceSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, importGraph } from '../chunk-SPT5JMME.js';
-import '../chunk-QBYTJSAY.js';
-import '../chunk-454I6GDF.js';
-import '../chunk-TQOYM4LN.js';
+export { ConflictStrategySchema, ExportOptionsSchema, ExportStreamOptionsSchema, FORMAT_VERSION, GraphDataHeaderSchema, GraphDataSchema, GraphDataSourceSchema, GraphInterchangeChunkSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream } from '../chunk-KMI7LYAF.js';
+import '../chunk-QNKSQTKQ.js';
+import '../chunk-QWEUYILR.js';
+import '../chunk-FPIZFYHE.js';
+import '../chunk-RGPG7EOJ.js';
+import '../chunk-CZQ3FO2Q.js';
+import '../chunk-UT3S4SEN.js';
+import '../chunk-JBTOYDMN.js';
+import '../chunk-I7ZUZKFD.js';
+import '../chunk-OHMP6N2J.js';
+import '../chunk-KBGQIPRQ.js';
+import '../chunk-SNXVDZAJ.js';
+import '../chunk-MP2JQKSG.js';
+import '../chunk-G6Q5UM7U.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{manager-BYl_zyZR.d.cts → manager-DwQi8eV0.d.cts}

@@ -1,5 +1,5 @@
-import { b as NodeRegistration, E as EdgeRegistration, D as DeleteBehavior, T as TemporalMode, G as GraphExtension, N as NodeType, A as AnyEdgeType, c as GraphDefaults, I as IndexEntity } from './extension-types-YGFJPrzK.cjs';
-import { O as OntologyRelation, I as IndexDeclaration, f as SerializedNodeDef, g as SerializedEdgeDef, k as SerializedSchema, H as SchemaVersionRow, G as GraphBackend } from './types-C_UnQOQp.cjs';
+import { b as NodeRegistration, E as EdgeRegistration, D as DeleteBehavior, T as TemporalMode, G as GraphExtension, N as NodeType, A as AnyEdgeType, c as GraphDefaults, I as IndexEntity } from './extension-types-ixRpJVUp.cjs';
+import { O as OntologyRelation, I as IndexDeclaration, u as SerializedNodeDef, v as SerializedEdgeDef, s as SerializedSchema, H as SchemaVersionRow, G as GraphBackend } from './fulltext-strategy-CDkSSYhq.cjs';
 
 /** Brand key for GraphDef */
 declare const GRAPH_DEF_BRAND: "__graphDef";
@@ -296,6 +296,13 @@ declare class KindRegistry {
      * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.
      */
     isAssignableTo(concreteKind: string, targetKind: string): boolean;
+    /**
+     * Checks if a concrete kind is assignable to at least one of the given
+     * target kinds. Shared by every "is this kind usable where one of these
+     * kinds is expected" check (edge endpoint validation, ontology relation
+     * endpoint compatibility) so they can't independently drift.
+     */
+    isAssignableToAny(concreteKind: string, targetKinds: readonly string[]): boolean;
     /**
      * Validates that a kind exists in the registry.
      */

package/dist/{manager-C0_r0ALf.d.ts → manager-ejUCB52T.d.ts}

@@ -1,5 +1,5 @@
-import { b as NodeRegistration, E as EdgeRegistration, D as DeleteBehavior, T as TemporalMode, G as GraphExtension, N as NodeType, A as AnyEdgeType, c as GraphDefaults, I as IndexEntity } from './extension-types-YGFJPrzK.js';
-import { O as OntologyRelation, I as IndexDeclaration, f as SerializedNodeDef, g as SerializedEdgeDef, k as SerializedSchema, H as SchemaVersionRow, G as GraphBackend } from './types-DGylBhWo.js';
+import { b as NodeRegistration, E as EdgeRegistration, D as DeleteBehavior, T as TemporalMode, G as GraphExtension, N as NodeType, A as AnyEdgeType, c as GraphDefaults, I as IndexEntity } from './extension-types-ixRpJVUp.js';
+import { O as OntologyRelation, I as IndexDeclaration, u as SerializedNodeDef, v as SerializedEdgeDef, s as SerializedSchema, H as SchemaVersionRow, G as GraphBackend } from './fulltext-strategy-B57yvC5Q.js';
 
 /** Brand key for GraphDef */
 declare const GRAPH_DEF_BRAND: "__graphDef";
@@ -296,6 +296,13 @@ declare class KindRegistry {
      * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.
      */
     isAssignableTo(concreteKind: string, targetKind: string): boolean;
+    /**
+     * Checks if a concrete kind is assignable to at least one of the given
+     * target kinds. Shared by every "is this kind usable where one of these
+     * kinds is expected" check (edge endpoint validation, ontology relation
+     * endpoint compatibility) so they can't independently drift.
+     */
+    isAssignableToAny(concreteKind: string, targetKinds: readonly string[]): boolean;
     /**
      * Validates that a kind exists in the registry.
      */

package/dist/{materialize-indexes-D20xNluI.d.cts → materialize-indexes-B4e9360H.d.cts}

@@ -1,4 +1,4 @@
-import { I as IndexEntity } from './extension-types-YGFJPrzK.cjs';
+import { I as IndexEntity } from './extension-types-ixRpJVUp.cjs';
 
 /**
  * Index materialization — runs declared index DDL against the live
@@ -23,9 +23,14 @@ import { I as IndexEntity } from './extension-types-YGFJPrzK.cjs';
  *   only that something with that name exists. Drift detection here
  *   relies on TypeGraph's recorded signature, not on PG metadata.
  * - Failed `CONCURRENTLY` builds leave invalid indexes behind
- *   (`pg_index.indisvalid = false`). v1 surfaces this as a `failed`
- *   result; the operator must drop the invalid index manually before
- *   retry.
+ *   (`pg_index.indisvalid = false`). Relational rebuilds self-heal: the
+ *   claim-holding materializer drops an invalid leftover with the
+ *   declaration's name before rebuilding (see dropInvalidIndexLeftover).
+ *   Vector per-field index leftovers remain operator-repair.
+ * - Two materializers racing the SAME index name serialize through a
+ *   durable claim in the status table (see materializeWithClaim) —
+ *   concurrent same-name expression-index CIC builds deadlock on
+ *   Postgres (no safe-snapshot exemption).
  */
 
 type MaterializeIndexesOptions = Readonly<{
@@ -33,6 +38,17 @@ type MaterializeIndexesOptions = Readonly<{
     kinds?: readonly string[];
     /** Stop on the first failure. Default: false (best-effort). */
     stopOnError?: boolean;
+    /**
+     * Refresh planner statistics (ANALYZE) after at least one index was
+     * created. A fresh index can be ignored by the planner until statistics
+     * exist. Default: true. Applied on non-concurrent builders (SQLite) and
+     * on concurrent builders that serialize same-index builds via the
+     * cross-caller claim primitive (the bundled Postgres backend); a custom
+     * concurrent backend without the primitive skips the refresh — see
+     * refreshStatisticsAfterCreation — and should call
+     * `store.refreshStatistics()` after materializing.
+     */
+    refreshStatistics?: boolean;
 }>;
 /**
  * Per-index outcome from `materializeIndexes()`.

package/dist/{materialize-indexes-CAkIYFV-.d.ts → materialize-indexes-te9TPMMJ.d.ts}

@@ -1,4 +1,4 @@
-import { I as IndexEntity } from './extension-types-YGFJPrzK.js';
+import { I as IndexEntity } from './extension-types-ixRpJVUp.js';
 
 /**
  * Index materialization — runs declared index DDL against the live
@@ -23,9 +23,14 @@ import { I as IndexEntity } from './extension-types-YGFJPrzK.js';
  *   only that something with that name exists. Drift detection here
  *   relies on TypeGraph's recorded signature, not on PG metadata.
  * - Failed `CONCURRENTLY` builds leave invalid indexes behind
- *   (`pg_index.indisvalid = false`). v1 surfaces this as a `failed`
- *   result; the operator must drop the invalid index manually before
- *   retry.
+ *   (`pg_index.indisvalid = false`). Relational rebuilds self-heal: the
+ *   claim-holding materializer drops an invalid leftover with the
+ *   declaration's name before rebuilding (see dropInvalidIndexLeftover).
+ *   Vector per-field index leftovers remain operator-repair.
+ * - Two materializers racing the SAME index name serialize through a
+ *   durable claim in the status table (see materializeWithClaim) —
+ *   concurrent same-name expression-index CIC builds deadlock on
+ *   Postgres (no safe-snapshot exemption).
  */
 
 type MaterializeIndexesOptions = Readonly<{
@@ -33,6 +38,17 @@ type MaterializeIndexesOptions = Readonly<{
     kinds?: readonly string[];
     /** Stop on the first failure. Default: false (best-effort). */
     stopOnError?: boolean;
+    /**
+     * Refresh planner statistics (ANALYZE) after at least one index was
+     * created. A fresh index can be ignored by the planner until statistics
+     * exist. Default: true. Applied on non-concurrent builders (SQLite) and
+     * on concurrent builders that serialize same-index builds via the
+     * cross-caller claim primitive (the bundled Postgres backend); a custom
+     * concurrent backend without the primitive skips the refresh — see
+     * refreshStatisticsAfterCreation — and should call
+     * `store.refreshStatistics()` after materializing.
+     */
+    refreshStatistics?: boolean;
 }>;
 /**
  * Per-index outcome from `materializeIndexes()`.

package/dist/{postgres-_9psmVGm.d.cts → postgres-CfEqsRMp.d.cts}

@@ -1,5 +1,5 @@
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { I as IndexDeclaration } from './types-C_UnQOQp.cjs';
+import { I as IndexDeclaration } from './fulltext-strategy-CDkSSYhq.cjs';
 
 /**
  * Table name configuration.
@@ -10,6 +10,7 @@ type PostgresTableNames = Readonly<{
     recordedNodes: string;
     recordedEdges: string;
     recordedClock: string;
+    revisionOrigins: string;
     uniques: string;
     schemaVersions: string;
     fulltext: string;
@@ -1121,6 +1122,47 @@ declare function createPostgresTables(names?: Partial<PostgresTableNames>, optio
         };
         dialect: "pg";
     }>;
+    readonly revisionOrigins: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: string;
+        schema: undefined;
+        columns: {
+            graphId: drizzle_orm_pg_core.PgColumn<{
+                name: "graph_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            origin: drizzle_orm_pg_core.PgColumn<{
+                name: "origin";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
     readonly uniques: drizzle_orm_pg_core.PgTableWithColumns<{
         name: string;
         schema: undefined;
@@ -1513,6 +1555,40 @@ declare function createPostgresTables(names?: Partial<PostgresTableNames>, optio
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            buildingSince: drizzle_orm_pg_core.PgColumn<{
+                name: "building_since";
+                tableName: string;
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            claimToken: drizzle_orm_pg_core.PgColumn<{
+                name: "claim_token";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: "pg";
     }>;
@@ -3053,6 +3129,47 @@ declare const tables: {
         };
         dialect: "pg";
     }>;
+    readonly revisionOrigins: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: string;
+        schema: undefined;
+        columns: {
+            graphId: drizzle_orm_pg_core.PgColumn<{
+                name: "graph_id";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            origin: drizzle_orm_pg_core.PgColumn<{
+                name: "origin";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
     readonly uniques: drizzle_orm_pg_core.PgTableWithColumns<{
         name: string;
         schema: undefined;
@@ -3445,6 +3562,40 @@ declare const tables: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            buildingSince: drizzle_orm_pg_core.PgColumn<{
+                name: "building_since";
+                tableName: string;
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            claimToken: drizzle_orm_pg_core.PgColumn<{
+                name: "claim_token";
+                tableName: string;
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: "pg";
     }>;