@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/core/index.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+var chunkPWXGB77L_cjs = require('../chunk-PWXGB77L.cjs');
+var chunkSVUKGWSN_cjs = require('../chunk-SVUKGWSN.cjs');
+var chunkRW24SAHI_cjs = require('../chunk-RW24SAHI.cjs');
+var chunkNT6ILURI_cjs = require('../chunk-NT6ILURI.cjs');
+require('../chunk-DDCYVIVV.cjs');
+var chunkHAHNRASW_cjs = require('../chunk-HAHNRASW.cjs');
+require('../chunk-NMQ6C6TS.cjs');
+require('../chunk-DI74SMXS.cjs');
+require('../chunk-XRU7V7FF.cjs');
+require('../chunk-SAFZ6JTI.cjs');
+
+
+
+Object.defineProperty(exports, "createExternalRef", {
+  enumerable: true,
+  get: function () { return chunkPWXGB77L_cjs.createExternalRef; }
+});
+Object.defineProperty(exports, "externalRef", {
+  enumerable: true,
+  get: function () { return chunkPWXGB77L_cjs.externalRef; }
+});
+Object.defineProperty(exports, "getExternalRefTable", {
+  enumerable: true,
+  get: function () { return chunkPWXGB77L_cjs.getExternalRefTable; }
+});
+Object.defineProperty(exports, "isExternalRefSchema", {
+  enumerable: true,
+  get: function () { return chunkPWXGB77L_cjs.isExternalRefSchema; }
+});
+Object.defineProperty(exports, "metaEdge", {
+  enumerable: true,
+  get: function () { return chunkPWXGB77L_cjs.metaEdge; }
+});
+Object.defineProperty(exports, "asRecordedInstant", {
+  enumerable: true,
+  get: function () { return chunkSVUKGWSN_cjs.asRecordedInstant; }
+});
+Object.defineProperty(exports, "defineEdge", {
+  enumerable: true,
+  get: function () { return chunkRW24SAHI_cjs.defineEdge; }
+});
+Object.defineProperty(exports, "defineNode", {
+  enumerable: true,
+  get: function () { return chunkRW24SAHI_cjs.defineNode; }
+});
+Object.defineProperty(exports, "asEdgeId", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.asEdgeId; }
+});
+Object.defineProperty(exports, "asNodeId", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.asNodeId; }
+});
+Object.defineProperty(exports, "defineGraph", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.defineGraph; }
+});
+Object.defineProperty(exports, "getEdgeKinds", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.getEdgeKinds; }
+});
+Object.defineProperty(exports, "getNodeKinds", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.getNodeKinds; }
+});
+Object.defineProperty(exports, "isEdgeType", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.isEdgeType; }
+});
+Object.defineProperty(exports, "isEdgeTypeWithEndpoints", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.isEdgeTypeWithEndpoints; }
+});
+Object.defineProperty(exports, "isGraphDef", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.isGraphDef; }
+});
+Object.defineProperty(exports, "isNodeType", {
+  enumerable: true,
+  get: function () { return chunkNT6ILURI_cjs.isNodeType; }
+});
+Object.defineProperty(exports, "DEFAULT_SEARCHABLE_LANGUAGE", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.DEFAULT_SEARCHABLE_LANGUAGE; }
+});
+Object.defineProperty(exports, "embedding", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.embedding; }
+});
+Object.defineProperty(exports, "getEmbeddingDimensions", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.getEmbeddingDimensions; }
+});
+Object.defineProperty(exports, "getSearchableMetadata", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.getSearchableMetadata; }
+});
+Object.defineProperty(exports, "isEmbeddingSchema", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.isEmbeddingSchema; }
+});
+Object.defineProperty(exports, "isSearchableSchema", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.isSearchableSchema; }
+});
+Object.defineProperty(exports, "resolveGraphVectorSlots", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.resolveGraphVectorSlots; }
+});
+Object.defineProperty(exports, "searchable", {
+  enumerable: true,
+  get: function () { return chunkHAHNRASW_cjs.searchable; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/core/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/core/index.d.cts

@@ -0,0 +1,225 @@
+import { z } from 'zod';
+import { l as KindAnnotations, a as NodeType, d as EdgeType } from '../extension-types-BLEVH4SG.cjs';
+export { A as AnyEdgeType, e as Cardinality, f as Collation, D as DeleteBehavior, g as EdgeId, h as EdgeProps, E as EdgeRegistration, i as EdgeTypeWithEndpoints, j as EndpointExistence, b as GraphDefaults, I as IndexEntity, J as JsonValue, K as KindEntity, m as NodeId, n as NodeProps, N as NodeRegistration, c as NullCheckOp, T as TemporalMode, U as UniqueConstraint, o as UniquenessScope, p as asEdgeId, q as asNodeId, r as isEdgeType, s as isEdgeTypeWithEndpoints, t as isNodeType } from '../extension-types-BLEVH4SG.cjs';
+import { D as InferenceType, at as MetaEdge } from '../index-CrFL_ENI.cjs';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, R as RecordedInstant, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as asRecordedInstant, g as embedding, h as getEmbeddingDimensions, i as getSearchableMetadata, j as isEmbeddingSchema, k as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../temporal-BC_NQV5Y.cjs';
+export { A as AllEdgeTypes, a as AllNodeTypes, E as EdgeKinds, b as GetEdgeType, c as GetNodeType, G as GraphDef, N as NodeKinds, d as defineGraph, g as getEdgeKinds, e as getNodeKinds, i as isGraphDef } from '../define-graph-CzEvA_8F.cjs';
+
+/**
+ * Options for defining a node type.
+ */
+type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
+    /** Zod schema for node properties */
+    schema: S;
+    /** Optional description for documentation */
+    description?: string;
+    /**
+     * Consumer-owned structured annotations for the kind.
+     *
+     * Stored in the canonical schema and **participates in schema hashing** —
+     * any change bumps the schema version and shows up as a `safe`-severity
+     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
+     */
+    annotations?: KindAnnotations;
+}>;
+/**
+ * Creates a node type definition.
+ *
+ * @example
+ * ```typescript
+ * const Person = defineNode("Person", {
+ *   schema: z.object({
+ *     fullName: z.string().min(1),
+ *     email: z.string().email().optional(),
+ *   }),
+ *   description: "A person in the system",
+ * });
+ * ```
+ */
+declare function defineNode<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineNodeOptions<S>): NodeType<K, S>;
+
+/**
+ * Options for defining an edge type.
+ */
+type DefineEdgeOptions<S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
+    /** Zod schema for edge properties (defaults to empty object) */
+    schema?: S;
+    /** Optional description for documentation */
+    description?: string;
+    /**
+     * Consumer-owned structured annotations for the kind.
+     *
+     * Stored in the canonical schema and **participates in schema hashing** —
+     * any change bumps the schema version and shows up as a `safe`-severity
+     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
+     */
+    annotations?: KindAnnotations;
+    /** Node types that can be the source of this edge (domain constraint) */
+    from?: From;
+    /** Node types that can be the target of this edge (range constraint) */
+    to?: To;
+}>;
+declare const EMPTY_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+type EmptySchema = typeof EMPTY_SCHEMA;
+/**
+ * Creates an edge type definition.
+ *
+ * @example
+ * ```typescript
+ * // Edge with no properties
+ * const hasEpisode = defineEdge("hasEpisode");
+ *
+ * // Edge with properties
+ * const employedAt = defineEdge("employedAt", {
+ *   schema: z.object({
+ *     isPrimary: z.boolean().default(true),
+ *     startedAt: z.date(),
+ *   }),
+ *   description: "Employment relationship",
+ * });
+ *
+ * // Edge with domain/range constraints (can be used directly in defineGraph)
+ * const worksAt = defineEdge("worksAt", {
+ *   schema: z.object({ role: z.string() }),
+ *   from: [Person],
+ *   to: [Company],
+ * });
+ * ```
+ */
+declare function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[], To extends readonly NodeType[]>(name: K, options: DefineEdgeOptions<S, From, To> & {
+    from: From;
+    to: To;
+}): EdgeType<K, S, From, To>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;
+
+/**
+ * Options for creating a meta-edge.
+ */
+type MetaEdgeOptions = Readonly<{
+    /** Whether the relationship is transitive (A→B, B→C implies A→C) */
+    transitive?: boolean;
+    /** Whether the relationship is symmetric (A→B implies B→A) */
+    symmetric?: boolean;
+    /** Whether the relationship is reflexive (A→A is always true) */
+    reflexive?: boolean;
+    /** Name of the inverse meta-edge */
+    inverse?: string;
+    /** How this meta-edge affects queries and validation */
+    inference?: InferenceType;
+    /** Optional description */
+    description?: string;
+}>;
+/**
+ * Creates a custom meta-edge definition.
+ *
+ * @example
+ * ```typescript
+ * // Custom meta-edge for regulatory relationships
+ * const regulatedBy = metaEdge("regulatedBy", {
+ *   description: "Type X is regulated by authority type Y",
+ *   transitive: false,
+ *   symmetric: false,
+ * });
+ * ```
+ */
+declare function metaEdge<K extends string>(name: K, options?: MetaEdgeOptions): MetaEdge<K>;
+
+/**
+ * External reference type for hybrid overlay patterns.
+ *
+ * Creates a Zod-compatible schema for referencing entities in external
+ * data sources (e.g., existing application tables) from TypeGraph nodes.
+ */
+
+/**
+ * Symbol key for storing external table name on the schema.
+ * This allows the schema introspector to detect external reference types
+ * and extract source information.
+ */
+declare const EXTERNAL_REF_TABLE_KEY: "_externalRefTable";
+/**
+ * The shape of an external reference value.
+ * Contains the source table identifier and the ID of the referenced record.
+ */
+type ExternalRefValue<T extends string = string> = Readonly<{
+    table: T;
+    id: string;
+}>;
+/**
+ * A Zod schema for external references with attached table metadata.
+ */
+type ExternalRefSchema<T extends string = string> = z.ZodType<ExternalRefValue<T>> & Readonly<{
+    [EXTERNAL_REF_TABLE_KEY]: T;
+}>;
+/**
+ * Creates a Zod schema for referencing external data sources.
+ *
+ * Use this when building a hybrid overlay where TypeGraph stores
+ * graph relationships and metadata while your existing tables
+ * remain the source of truth for entity data.
+ *
+ * @param table - The identifier for the external table/source (e.g., "users", "documents")
+ * @returns A Zod schema that validates external reference objects
+ *
+ * @example
+ * ```typescript
+ * import { defineNode, externalRef, embedding } from "@nicia-ai/typegraph";
+ *
+ * // Reference documents from your existing application database
+ * const Document = defineNode("Document", {
+ *   schema: z.object({
+ *     source: externalRef("documents"),
+ *     embedding: embedding(1536).optional(),
+ *     extractedTopics: z.array(z.string()).optional(),
+ *   }),
+ * });
+ *
+ * // Create a node referencing an external document
+ * await store.nodes.Document.create({
+ *   source: { table: "documents", id: "doc_abc123" },
+ *   embedding: await generateEmbedding(docContent),
+ * });
+ *
+ * // Query and hydrate with external data
+ * const results = await store
+ *   .query()
+ *   .from("Document", "d")
+ *   .whereNode("d", (d) => d.embedding.similarTo(query, 10))
+ *   .select((ctx) => ctx.d.source)
+ *   .execute();
+ *
+ * // Fetch full data from your app database
+ * const externalIds = results.map((r) => r.id);
+ * const fullDocs = await appDb.query.documents.findMany({
+ *   where: inArray(documents.id, externalIds),
+ * });
+ * ```
+ */
+declare function externalRef<T extends string>(table: T): ExternalRefSchema<T>;
+/**
+ * Checks if a value is an external reference schema.
+ */
+declare function isExternalRefSchema(value: unknown): value is ExternalRefSchema;
+/**
+ * Gets the table name from an external reference schema.
+ * Returns undefined if the schema is not an external reference schema.
+ */
+declare function getExternalRefTable(schema: z.ZodType): string | undefined;
+/**
+ * Helper function to create a typed external reference value.
+ * Useful when you want to avoid repeating the table name.
+ *
+ * @example
+ * ```typescript
+ * const docRef = createExternalRef("documents");
+ *
+ * await store.nodes.Document.create({
+ *   source: docRef("doc_123"),
+ *   embedding: [...],
+ * });
+ * ```
+ */
+declare function createExternalRef<T extends string>(table: T): (id: string) => ExternalRefValue<T>;
+
+export { type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, KindAnnotations, type MetaEdgeOptions, NodeType, createExternalRef, defineEdge, defineNode, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge };

package/dist/core/index.d.ts

@@ -0,0 +1,225 @@
+import { z } from 'zod';
+import { l as KindAnnotations, a as NodeType, d as EdgeType } from '../extension-types-BLEVH4SG.js';
+export { A as AnyEdgeType, e as Cardinality, f as Collation, D as DeleteBehavior, g as EdgeId, h as EdgeProps, E as EdgeRegistration, i as EdgeTypeWithEndpoints, j as EndpointExistence, b as GraphDefaults, I as IndexEntity, J as JsonValue, K as KindEntity, m as NodeId, n as NodeProps, N as NodeRegistration, c as NullCheckOp, T as TemporalMode, U as UniqueConstraint, o as UniquenessScope, p as asEdgeId, q as asNodeId, r as isEdgeType, s as isEdgeTypeWithEndpoints, t as isNodeType } from '../extension-types-BLEVH4SG.js';
+import { D as InferenceType, at as MetaEdge } from '../index-Bq7vSPHy.js';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, R as RecordedInstant, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as asRecordedInstant, g as embedding, h as getEmbeddingDimensions, i as getSearchableMetadata, j as isEmbeddingSchema, k as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from '../temporal-DqtOEo_B.js';
+export { A as AllEdgeTypes, a as AllNodeTypes, E as EdgeKinds, b as GetEdgeType, c as GetNodeType, G as GraphDef, N as NodeKinds, d as defineGraph, g as getEdgeKinds, e as getNodeKinds, i as isGraphDef } from '../define-graph-DRo9xpYN.js';
+
+/**
+ * Options for defining a node type.
+ */
+type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
+    /** Zod schema for node properties */
+    schema: S;
+    /** Optional description for documentation */
+    description?: string;
+    /**
+     * Consumer-owned structured annotations for the kind.
+     *
+     * Stored in the canonical schema and **participates in schema hashing** —
+     * any change bumps the schema version and shows up as a `safe`-severity
+     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
+     */
+    annotations?: KindAnnotations;
+}>;
+/**
+ * Creates a node type definition.
+ *
+ * @example
+ * ```typescript
+ * const Person = defineNode("Person", {
+ *   schema: z.object({
+ *     fullName: z.string().min(1),
+ *     email: z.string().email().optional(),
+ *   }),
+ *   description: "A person in the system",
+ * });
+ * ```
+ */
+declare function defineNode<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineNodeOptions<S>): NodeType<K, S>;
+
+/**
+ * Options for defining an edge type.
+ */
+type DefineEdgeOptions<S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
+    /** Zod schema for edge properties (defaults to empty object) */
+    schema?: S;
+    /** Optional description for documentation */
+    description?: string;
+    /**
+     * Consumer-owned structured annotations for the kind.
+     *
+     * Stored in the canonical schema and **participates in schema hashing** —
+     * any change bumps the schema version and shows up as a `safe`-severity
+     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
+     */
+    annotations?: KindAnnotations;
+    /** Node types that can be the source of this edge (domain constraint) */
+    from?: From;
+    /** Node types that can be the target of this edge (range constraint) */
+    to?: To;
+}>;
+declare const EMPTY_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+type EmptySchema = typeof EMPTY_SCHEMA;
+/**
+ * Creates an edge type definition.
+ *
+ * @example
+ * ```typescript
+ * // Edge with no properties
+ * const hasEpisode = defineEdge("hasEpisode");
+ *
+ * // Edge with properties
+ * const employedAt = defineEdge("employedAt", {
+ *   schema: z.object({
+ *     isPrimary: z.boolean().default(true),
+ *     startedAt: z.date(),
+ *   }),
+ *   description: "Employment relationship",
+ * });
+ *
+ * // Edge with domain/range constraints (can be used directly in defineGraph)
+ * const worksAt = defineEdge("worksAt", {
+ *   schema: z.object({ role: z.string() }),
+ *   from: [Person],
+ *   to: [Company],
+ * });
+ * ```
+ */
+declare function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[], To extends readonly NodeType[]>(name: K, options: DefineEdgeOptions<S, From, To> & {
+    from: From;
+    to: To;
+}): EdgeType<K, S, From, To>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;
+
+/**
+ * Options for creating a meta-edge.
+ */
+type MetaEdgeOptions = Readonly<{
+    /** Whether the relationship is transitive (A→B, B→C implies A→C) */
+    transitive?: boolean;
+    /** Whether the relationship is symmetric (A→B implies B→A) */
+    symmetric?: boolean;
+    /** Whether the relationship is reflexive (A→A is always true) */
+    reflexive?: boolean;
+    /** Name of the inverse meta-edge */
+    inverse?: string;
+    /** How this meta-edge affects queries and validation */
+    inference?: InferenceType;
+    /** Optional description */
+    description?: string;
+}>;
+/**
+ * Creates a custom meta-edge definition.
+ *
+ * @example
+ * ```typescript
+ * // Custom meta-edge for regulatory relationships
+ * const regulatedBy = metaEdge("regulatedBy", {
+ *   description: "Type X is regulated by authority type Y",
+ *   transitive: false,
+ *   symmetric: false,
+ * });
+ * ```
+ */
+declare function metaEdge<K extends string>(name: K, options?: MetaEdgeOptions): MetaEdge<K>;
+
+/**
+ * External reference type for hybrid overlay patterns.
+ *
+ * Creates a Zod-compatible schema for referencing entities in external
+ * data sources (e.g., existing application tables) from TypeGraph nodes.
+ */
+
+/**
+ * Symbol key for storing external table name on the schema.
+ * This allows the schema introspector to detect external reference types
+ * and extract source information.
+ */
+declare const EXTERNAL_REF_TABLE_KEY: "_externalRefTable";
+/**
+ * The shape of an external reference value.
+ * Contains the source table identifier and the ID of the referenced record.
+ */
+type ExternalRefValue<T extends string = string> = Readonly<{
+    table: T;
+    id: string;
+}>;
+/**
+ * A Zod schema for external references with attached table metadata.
+ */
+type ExternalRefSchema<T extends string = string> = z.ZodType<ExternalRefValue<T>> & Readonly<{
+    [EXTERNAL_REF_TABLE_KEY]: T;
+}>;
+/**
+ * Creates a Zod schema for referencing external data sources.
+ *
+ * Use this when building a hybrid overlay where TypeGraph stores
+ * graph relationships and metadata while your existing tables
+ * remain the source of truth for entity data.
+ *
+ * @param table - The identifier for the external table/source (e.g., "users", "documents")
+ * @returns A Zod schema that validates external reference objects
+ *
+ * @example
+ * ```typescript
+ * import { defineNode, externalRef, embedding } from "@nicia-ai/typegraph";
+ *
+ * // Reference documents from your existing application database
+ * const Document = defineNode("Document", {
+ *   schema: z.object({
+ *     source: externalRef("documents"),
+ *     embedding: embedding(1536).optional(),
+ *     extractedTopics: z.array(z.string()).optional(),
+ *   }),
+ * });
+ *
+ * // Create a node referencing an external document
+ * await store.nodes.Document.create({
+ *   source: { table: "documents", id: "doc_abc123" },
+ *   embedding: await generateEmbedding(docContent),
+ * });
+ *
+ * // Query and hydrate with external data
+ * const results = await store
+ *   .query()
+ *   .from("Document", "d")
+ *   .whereNode("d", (d) => d.embedding.similarTo(query, 10))
+ *   .select((ctx) => ctx.d.source)
+ *   .execute();
+ *
+ * // Fetch full data from your app database
+ * const externalIds = results.map((r) => r.id);
+ * const fullDocs = await appDb.query.documents.findMany({
+ *   where: inArray(documents.id, externalIds),
+ * });
+ * ```
+ */
+declare function externalRef<T extends string>(table: T): ExternalRefSchema<T>;
+/**
+ * Checks if a value is an external reference schema.
+ */
+declare function isExternalRefSchema(value: unknown): value is ExternalRefSchema;
+/**
+ * Gets the table name from an external reference schema.
+ * Returns undefined if the schema is not an external reference schema.
+ */
+declare function getExternalRefTable(schema: z.ZodType): string | undefined;
+/**
+ * Helper function to create a typed external reference value.
+ * Useful when you want to avoid repeating the table name.
+ *
+ * @example
+ * ```typescript
+ * const docRef = createExternalRef("documents");
+ *
+ * await store.nodes.Document.create({
+ *   source: docRef("doc_123"),
+ *   embedding: [...],
+ * });
+ * ```
+ */
+declare function createExternalRef<T extends string>(table: T): (id: string) => ExternalRefValue<T>;
+
+export { type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, KindAnnotations, type MetaEdgeOptions, NodeType, createExternalRef, defineEdge, defineNode, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge };

package/dist/core/index.js

@@ -0,0 +1,12 @@
+export { createExternalRef, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge } from '../chunk-3LKL3S6X.js';
+export { asRecordedInstant } from '../chunk-J6IJARLG.js';
+export { defineEdge, defineNode } from '../chunk-76HE7DJP.js';
+export { asEdgeId, asNodeId, defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from '../chunk-PH4IJ3V5.js';
+import '../chunk-I6FX7AAG.js';
+export { DEFAULT_SEARCHABLE_LANGUAGE, embedding, getEmbeddingDimensions, getSearchableMetadata, isEmbeddingSchema, isSearchableSchema, resolveGraphVectorSlots, searchable } from '../chunk-PC2UBAUB.js';
+import '../chunk-TAUGGLNQ.js';
+import '../chunk-ITE4IXAK.js';
+import '../chunk-XZA3Y4YH.js';
+import '../chunk-DPNA466P.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/{ddl-CS0KUVwB.d.ts → ddl-Dx3Z0_WC.d.ts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './fulltext-strategy-DebsMrqg.js';
-import { P as PostgresTables } from './postgres-IaBA4RgE.js';
-import { S as SqliteTables } from './sqlite-BUOHPx7p.js';
+import { F as FulltextStrategy } from './index-Bq7vSPHy.js';
+import { P as PostgresTables } from './postgres-Cl1ZAN1G.js';
+import { S as SqliteTables } from './sqlite-CYfhvESj.js';
 
 /**
  * Generates all DDL statements for the given SQLite tables.

package/dist/{ddl-BD-ZfKeX.d.cts → ddl-J6sDyABg.d.cts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './fulltext-strategy-C27vXaeB.cjs';
-import { P as PostgresTables } from './postgres-YrYmPlaU.cjs';
-import { S as SqliteTables } from './sqlite-Pp8O19WE.cjs';
+import { F as FulltextStrategy } from './index-CrFL_ENI.cjs';
+import { P as PostgresTables } from './postgres-DMgIKQU-.cjs';
+import { S as SqliteTables } from './sqlite-BDkW39aa.cjs';
 
 /**
  * Generates all DDL statements for the given SQLite tables.