@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/indexes/index.cjs

@@ -1,15 +1,16 @@
 'use strict';
 
 var chunkAW4A3P5A_cjs = require('../chunk-AW4A3P5A.cjs');
-var chunk3QRBXYT5_cjs = require('../chunk-3QRBXYT5.cjs');
-var chunk3IR2GEMJ_cjs = require('../chunk-3IR2GEMJ.cjs');
-require('../chunk-EF3Z645U.cjs');
-require('../chunk-ZFWNO3GE.cjs');
-var chunkWWVV44DY_cjs = require('../chunk-WWVV44DY.cjs');
-require('../chunk-CFNT3ITG.cjs');
-require('../chunk-73KASJGO.cjs');
-require('../chunk-3E7SNSIA.cjs');
-require('../chunk-FLRCVI2G.cjs');
+var chunkS55OV6PW_cjs = require('../chunk-S55OV6PW.cjs');
+var chunkFACJJWGF_cjs = require('../chunk-FACJJWGF.cjs');
+var chunkUUT7UN2N_cjs = require('../chunk-UUT7UN2N.cjs');
+require('../chunk-TEDRJXOG.cjs');
+require('../chunk-D7ZEOS56.cjs');
+require('../chunk-UMDVATGY.cjs');
+require('../chunk-7YSP4V4R.cjs');
+require('../chunk-H7YNSMA7.cjs');
+require('../chunk-SJDMVITW.cjs');
+require('../chunk-TDXIBCGY.cjs');
 
 
 
@@ -33,41 +34,41 @@ Object.defineProperty(exports, "toDeclaredIndexes", {
   enumerable: true,
   get: function () { return chunkAW4A3P5A_cjs.toDeclaredIndexes; }
 });
-Object.defineProperty(exports, "generateEdgeIndexDDL", {
+Object.defineProperty(exports, "buildPostgresEdgeIndexBuilders", {
   enumerable: true,
-  get: function () { return chunk3QRBXYT5_cjs.generateEdgeIndexDDL; }
+  get: function () { return chunkS55OV6PW_cjs.buildPostgresEdgeIndexBuilders; }
 });
-Object.defineProperty(exports, "generateIndexDDL", {
+Object.defineProperty(exports, "buildPostgresNodeIndexBuilders", {
   enumerable: true,
-  get: function () { return chunk3QRBXYT5_cjs.generateIndexDDL; }
+  get: function () { return chunkS55OV6PW_cjs.buildPostgresNodeIndexBuilders; }
 });
-Object.defineProperty(exports, "generateNodeIndexDDL", {
+Object.defineProperty(exports, "buildSqliteEdgeIndexBuilders", {
   enumerable: true,
-  get: function () { return chunk3QRBXYT5_cjs.generateNodeIndexDDL; }
+  get: function () { return chunkS55OV6PW_cjs.buildSqliteEdgeIndexBuilders; }
 });
-Object.defineProperty(exports, "defineEdgeIndex", {
+Object.defineProperty(exports, "buildSqliteNodeIndexBuilders", {
   enumerable: true,
-  get: function () { return chunk3IR2GEMJ_cjs.defineEdgeIndex; }
+  get: function () { return chunkS55OV6PW_cjs.buildSqliteNodeIndexBuilders; }
 });
-Object.defineProperty(exports, "defineNodeIndex", {
+Object.defineProperty(exports, "generateEdgeIndexDDL", {
   enumerable: true,
-  get: function () { return chunk3IR2GEMJ_cjs.defineNodeIndex; }
+  get: function () { return chunkFACJJWGF_cjs.generateEdgeIndexDDL; }
 });
-Object.defineProperty(exports, "buildPostgresEdgeIndexBuilders", {
+Object.defineProperty(exports, "generateIndexDDL", {
   enumerable: true,
-  get: function () { return chunkWWVV44DY_cjs.buildPostgresEdgeIndexBuilders; }
+  get: function () { return chunkFACJJWGF_cjs.generateIndexDDL; }
 });
-Object.defineProperty(exports, "buildPostgresNodeIndexBuilders", {
+Object.defineProperty(exports, "generateNodeIndexDDL", {
   enumerable: true,
-  get: function () { return chunkWWVV44DY_cjs.buildPostgresNodeIndexBuilders; }
+  get: function () { return chunkFACJJWGF_cjs.generateNodeIndexDDL; }
 });
-Object.defineProperty(exports, "buildSqliteEdgeIndexBuilders", {
+Object.defineProperty(exports, "defineEdgeIndex", {
   enumerable: true,
-  get: function () { return chunkWWVV44DY_cjs.buildSqliteEdgeIndexBuilders; }
+  get: function () { return chunkUUT7UN2N_cjs.defineEdgeIndex; }
 });
-Object.defineProperty(exports, "buildSqliteNodeIndexBuilders", {
+Object.defineProperty(exports, "defineNodeIndex", {
   enumerable: true,
-  get: function () { return chunkWWVV44DY_cjs.buildSqliteNodeIndexBuilders; }
+  get: function () { return chunkUUT7UN2N_cjs.defineNodeIndex; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/indexes/index.d.cts

@@ -1,12 +1,12 @@
-import { c as EdgeIndexDeclaration, p as SqlDialect, R as RelationalIndexDeclaration, d as NodeIndexDeclaration, I as IndexDeclaration } from '../types-C_UnQOQp.cjs';
-export { E as EdgeIndexConfig, q as EdgeIndexDirection, r as EdgeIndexWhereBuilder, s as IndexOrigin, t as IndexScope, e as IndexWhereExpression, u as IndexWhereFieldBuilder, v as IndexWhereInput, N as NodeIndexConfig, w as NodeIndexWhereBuilder, x as SystemColumnName, y as VectorIndexDeclaration, z as VectorIndexImplementation, C as VectorIndexMetric, D as VectorIndexParams } from '../types-C_UnQOQp.cjs';
-export { a as andWhere, d as defineEdgeIndex, b as defineNodeIndex, n as notWhere, o as orWhere } from '../where-Bpp2ul_z.cjs';
+import { c as EdgeIndexDeclaration, f as SqlDialect, R as RelationalIndexDeclaration, d as NodeIndexDeclaration, I as IndexDeclaration } from '../fulltext-strategy-CDkSSYhq.cjs';
+export { E as EdgeIndexConfig, g as EdgeIndexDirection, h as EdgeIndexWhereBuilder, i as IndexOrigin, j as IndexScope, e as IndexWhereExpression, k as IndexWhereFieldBuilder, l as IndexWhereInput, N as NodeIndexConfig, m as NodeIndexWhereBuilder, n as SystemColumnName, o as VectorIndexDeclaration, p as VectorIndexImplementation, q as VectorIndexMetric, r as VectorIndexParams } from '../fulltext-strategy-CDkSSYhq.cjs';
+export { a as andWhere, d as defineEdgeIndex, b as defineNodeIndex, n as notWhere, o as orWhere } from '../where-DdMIXOtH.cjs';
 import { SQLWrapper } from 'drizzle-orm';
 import { IndexBuilder } from 'drizzle-orm/pg-core';
 import { IndexBuilder as IndexBuilder$1 } from 'drizzle-orm/sqlite-core';
-import { D as DeclaredIndex } from '../types-B6mhrcLv.cjs';
+import { D as DeclaredIndex } from '../types-Bv9DcS_E.cjs';
+import '../extension-types-ixRpJVUp.cjs';
 import 'zod';
-import '../extension-types-YGFJPrzK.cjs';
 
 type GenerateIndexDdlOptions = Readonly<{
     nodesTableName?: string | undefined;

package/dist/indexes/index.d.ts

@@ -1,12 +1,12 @@
-import { c as EdgeIndexDeclaration, p as SqlDialect, R as RelationalIndexDeclaration, d as NodeIndexDeclaration, I as IndexDeclaration } from '../types-DGylBhWo.js';
-export { E as EdgeIndexConfig, q as EdgeIndexDirection, r as EdgeIndexWhereBuilder, s as IndexOrigin, t as IndexScope, e as IndexWhereExpression, u as IndexWhereFieldBuilder, v as IndexWhereInput, N as NodeIndexConfig, w as NodeIndexWhereBuilder, x as SystemColumnName, y as VectorIndexDeclaration, z as VectorIndexImplementation, C as VectorIndexMetric, D as VectorIndexParams } from '../types-DGylBhWo.js';
-export { a as andWhere, d as defineEdgeIndex, b as defineNodeIndex, n as notWhere, o as orWhere } from '../where-BsEXraKW.js';
+import { c as EdgeIndexDeclaration, f as SqlDialect, R as RelationalIndexDeclaration, d as NodeIndexDeclaration, I as IndexDeclaration } from '../fulltext-strategy-B57yvC5Q.js';
+export { E as EdgeIndexConfig, g as EdgeIndexDirection, h as EdgeIndexWhereBuilder, i as IndexOrigin, j as IndexScope, e as IndexWhereExpression, k as IndexWhereFieldBuilder, l as IndexWhereInput, N as NodeIndexConfig, m as NodeIndexWhereBuilder, n as SystemColumnName, o as VectorIndexDeclaration, p as VectorIndexImplementation, q as VectorIndexMetric, r as VectorIndexParams } from '../fulltext-strategy-B57yvC5Q.js';
+export { a as andWhere, d as defineEdgeIndex, b as defineNodeIndex, n as notWhere, o as orWhere } from '../where-7RKFOsXt.js';
 import { SQLWrapper } from 'drizzle-orm';
 import { IndexBuilder } from 'drizzle-orm/pg-core';
 import { IndexBuilder as IndexBuilder$1 } from 'drizzle-orm/sqlite-core';
-import { D as DeclaredIndex } from '../types-CdWxK-nD.js';
+import { D as DeclaredIndex } from '../types-CoxuV7EJ.js';
+import '../extension-types-ixRpJVUp.js';
 import 'zod';
-import '../extension-types-YGFJPrzK.js';
 
 type GenerateIndexDdlOptions = Readonly<{
     nodesTableName?: string | undefined;

package/dist/indexes/index.js

@@ -1,12 +1,13 @@
 export { andWhere, notWhere, orWhere, toDeclaredIndex, toDeclaredIndexes } from '../chunk-A3W7QG7K.js';
-export { generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL } from '../chunk-PIHXFF73.js';
-export { defineEdgeIndex, defineNodeIndex } from '../chunk-6NRFUHMS.js';
-import '../chunk-IZ4PCL47.js';
-import '../chunk-454I6GDF.js';
-export { buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders } from '../chunk-CWFPJ3RC.js';
-import '../chunk-C4C4Q7A6.js';
-import '../chunk-2YMGNYXY.js';
-import '../chunk-XLUNB2TZ.js';
-import '../chunk-K5P5OZXS.js';
+export { buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders } from '../chunk-6FR2MMS6.js';
+export { generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL } from '../chunk-UZV3AZKF.js';
+export { defineEdgeIndex, defineNodeIndex } from '../chunk-OR5ZA5WP.js';
+import '../chunk-W63OVYY4.js';
+import '../chunk-FPIZFYHE.js';
+import '../chunk-5SEGFTZX.js';
+import '../chunk-OHMP6N2J.js';
+import '../chunk-KBGQIPRQ.js';
+import '../chunk-SNXVDZAJ.js';
+import '../chunk-G6Q5UM7U.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/interchange/index.cjs

@@ -1,63 +1,93 @@
 'use strict';
 
-var chunkSST7XDY6_cjs = require('../chunk-SST7XDY6.cjs');
-require('../chunk-MBLXCV2Y.cjs');
-require('../chunk-ZFWNO3GE.cjs');
-require('../chunk-JIEJCTDS.cjs');
+var chunk4JEZZJ6S_cjs = require('../chunk-4JEZZJ6S.cjs');
+require('../chunk-WJT7OU7E.cjs');
+require('../chunk-VPYHY3LJ.cjs');
+require('../chunk-D7ZEOS56.cjs');
+require('../chunk-GSQ6NPH6.cjs');
+require('../chunk-XOX22WHL.cjs');
+require('../chunk-EOLERH7Y.cjs');
+require('../chunk-4TOD4LBZ.cjs');
+require('../chunk-BLZDPRXT.cjs');
+require('../chunk-7YSP4V4R.cjs');
+require('../chunk-H7YNSMA7.cjs');
+require('../chunk-SJDMVITW.cjs');
+require('../chunk-LGEALRC6.cjs');
+require('../chunk-TDXIBCGY.cjs');
 
 
 
 Object.defineProperty(exports, "ConflictStrategySchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.ConflictStrategySchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.ConflictStrategySchema; }
 });
 Object.defineProperty(exports, "ExportOptionsSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.ExportOptionsSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.ExportOptionsSchema; }
+});
+Object.defineProperty(exports, "ExportStreamOptionsSchema", {
+  enumerable: true,
+  get: function () { return chunk4JEZZJ6S_cjs.ExportStreamOptionsSchema; }
 });
 Object.defineProperty(exports, "FORMAT_VERSION", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.FORMAT_VERSION; }
+  get: function () { return chunk4JEZZJ6S_cjs.FORMAT_VERSION; }
+});
+Object.defineProperty(exports, "GraphDataHeaderSchema", {
+  enumerable: true,
+  get: function () { return chunk4JEZZJ6S_cjs.GraphDataHeaderSchema; }
 });
 Object.defineProperty(exports, "GraphDataSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.GraphDataSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.GraphDataSchema; }
 });
 Object.defineProperty(exports, "GraphDataSourceSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.GraphDataSourceSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.GraphDataSourceSchema; }
+});
+Object.defineProperty(exports, "GraphInterchangeChunkSchema", {
+  enumerable: true,
+  get: function () { return chunk4JEZZJ6S_cjs.GraphInterchangeChunkSchema; }
 });
 Object.defineProperty(exports, "ImportErrorSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.ImportErrorSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.ImportErrorSchema; }
 });
 Object.defineProperty(exports, "ImportOptionsSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.ImportOptionsSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.ImportOptionsSchema; }
 });
 Object.defineProperty(exports, "ImportResultSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.ImportResultSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.ImportResultSchema; }
 });
 Object.defineProperty(exports, "InterchangeEdgeSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.InterchangeEdgeSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.InterchangeEdgeSchema; }
 });
 Object.defineProperty(exports, "InterchangeNodeSchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.InterchangeNodeSchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.InterchangeNodeSchema; }
 });
 Object.defineProperty(exports, "UnknownPropertyStrategySchema", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.UnknownPropertyStrategySchema; }
+  get: function () { return chunk4JEZZJ6S_cjs.UnknownPropertyStrategySchema; }
 });
 Object.defineProperty(exports, "exportGraph", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.exportGraph; }
+  get: function () { return chunk4JEZZJ6S_cjs.exportGraph; }
+});
+Object.defineProperty(exports, "exportGraphStream", {
+  enumerable: true,
+  get: function () { return chunk4JEZZJ6S_cjs.exportGraphStream; }
 });
 Object.defineProperty(exports, "importGraph", {
   enumerable: true,
-  get: function () { return chunkSST7XDY6_cjs.importGraph; }
+  get: function () { return chunk4JEZZJ6S_cjs.importGraph; }
+});
+Object.defineProperty(exports, "importGraphStream", {
+  enumerable: true,
+  get: function () { return chunk4JEZZJ6S_cjs.importGraphStream; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/interchange/index.d.cts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
-import { G as GraphDef } from '../manager-BYl_zyZR.cjs';
-import { S as Store } from '../store-view-9jQ2rPum.cjs';
-import '../extension-types-YGFJPrzK.cjs';
-import '../types-C_UnQOQp.cjs';
+import { G as GraphDef } from '../manager-DwQi8eV0.cjs';
+import { S as Store } from '../store-view-BSpqvAxK.cjs';
+import '../extension-types-ixRpJVUp.cjs';
+import '../fulltext-strategy-CDkSSYhq.cjs';
 import 'drizzle-orm';
 import 'drizzle-orm/pg-core';
 import 'drizzle-orm/sqlite-core';
-import '../materialize-indexes-D20xNluI.cjs';
+import '../materialize-indexes-B4e9360H.cjs';
 
 /**
  * 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 };