@getzep/zep-cloud 3.0.0 → 3.0.2

package/dist/cjs/serialization/types/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiError.js"), exports);
+__exportStar(require("./AddThreadMessagesResponse.js"), exports);
+__exportStar(require("./CloneGraphResponse.js"), exports);
+__exportStar(require("./EdgeType.js"), exports);
+__exportStar(require("./EntityEdgeSourceTarget.js"), exports);
+__exportStar(require("./EntityProperty.js"), exports);
+__exportStar(require("./EntityType.js"), exports);
+__exportStar(require("./EntityTypeResponse.js"), exports);
+__exportStar(require("./EpisodeData.js"), exports);
+__exportStar(require("./EpisodeMentions.js"), exports);
+__exportStar(require("./FactRatingExamples.js"), exports);
+__exportStar(require("./FactRatingInstruction.js"), exports);
+__exportStar(require("./Graph.js"), exports);
+__exportStar(require("./GraphEdgesRequest.js"), exports);
+__exportStar(require("./Episode.js"), exports);
+__exportStar(require("./EpisodeResponse.js"), exports);
+__exportStar(require("./GraphListResponse.js"), exports);
+__exportStar(require("./GraphNodesRequest.js"), exports);
+__exportStar(require("./GraphSearchResults.js"), exports);
+__exportStar(require("./RoleType.js"), exports);
+__exportStar(require("./SuccessResponse.js"), exports);
+__exportStar(require("./Thread.js"), exports);
+__exportStar(require("./ThreadContextResponse.js"), exports);
+__exportStar(require("./ThreadListResponse.js"), exports);
+__exportStar(require("./Message.js"), exports);
+__exportStar(require("./MessageListResponse.js"), exports);
+__exportStar(require("./User.js"), exports);
+__exportStar(require("./UserListResponse.js"), exports);
+__exportStar(require("./UserNodeResponse.js"), exports);
+__exportStar(require("./AddTripleResponse.js"), exports);
+__exportStar(require("./ComparisonOperator.js"), exports);
+__exportStar(require("./DateFilter.js"), exports);
+__exportStar(require("./EntityEdge.js"), exports);
+__exportStar(require("./EntityNode.js"), exports);
+__exportStar(require("./GraphSearchScope.js"), exports);
+__exportStar(require("./Reranker.js"), exports);
+__exportStar(require("./SearchFilters.js"), exports);
+__exportStar(require("./EntityPropertyType.js"), exports);
+__exportStar(require("./ModelsFactRatingExamples.js"), exports);
+__exportStar(require("./ModelsFactRatingInstruction.js"), exports);
+__exportStar(require("./GraphDataType.js"), exports);

package/dist/cjs/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "3.0.0";

package/dist/cjs/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = "3.0.0";

package/dist/cjs/wrapper/graph.d.ts

@@ -0,0 +1,83 @@
+import { Graph as BaseGraph } from "../api/resources/graph/client/Client";
+import { Zep } from "../index";
+import { EdgeType, EntityType } from "./ontology";
+export declare class Graph extends BaseGraph {
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setEntityTypes({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setEntityTypes(entityTypes: Record<string, EntityType>, edgeTypes: Record<string, EdgeType>, requestOptions?: BaseGraph.RequestOptions): Promise<Zep.SuccessResponse>;
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setOntology({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setOntology(entityTypes: Record<string, EntityType>, edgeTypes: Record<string, EdgeType>, requestOptions?: BaseGraph.RequestOptions): Promise<Zep.SuccessResponse>;
+}

package/dist/cjs/wrapper/graph.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+const Client_1 = require("../api/resources/graph/client/Client");
+const ontology_1 = require("./ontology");
+class Graph extends Client_1.Graph {
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setEntityTypes({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setEntityTypes(entityTypes, edgeTypes, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validatedEntityTypes = Object.keys(entityTypes).map((key) => {
+                const schema = entityTypes[key];
+                return (0, ontology_1.entityModelToAPISchema)(schema, key);
+            });
+            const validatedEdgeTypes = Object.keys(edgeTypes).map((key) => {
+                const schema = edgeTypes[key];
+                return (0, ontology_1.edgeModelToAPISchema)(schema, key);
+            });
+            return this.setEntityTypesInternal({
+                entityTypes: validatedEntityTypes,
+                edgeTypes: validatedEdgeTypes,
+            }, requestOptions);
+        });
+    }
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setOntology({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setOntology(entityTypes, edgeTypes, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setEntityTypes(entityTypes, edgeTypes, requestOptions);
+        });
+    }
+}
+exports.Graph = Graph;

package/dist/cjs/wrapper/index.d.ts

@@ -0,0 +1,5 @@
+import { ZepClient as BaseClient } from "../Client";
+import { Graph } from "./graph";
+export declare class ZepClient extends BaseClient {
+    get graph(): Graph;
+}

package/dist/cjs/wrapper/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZepClient = void 0;
+const Client_1 = require("../Client");
+const graph_1 = require("./graph");
+class ZepClient extends Client_1.ZepClient {
+    get graph() {
+        return new graph_1.Graph(this._options);
+    }
+}
+exports.ZepClient = ZepClient;

package/dist/cjs/wrapper/ontology.d.ts

@@ -0,0 +1,416 @@
+import { z } from "zod";
+import { Zep } from "../index";
+export declare enum EntityPropertyType {
+    Text = "Text",
+    Int = "Int",
+    Float = "Float",
+    Boolean = "Boolean"
+}
+export declare const EntityTypeBaseField: z.ZodObject<{
+    type: z.ZodNativeEnum<typeof EntityPropertyType>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType;
+    description: string;
+}, {
+    type: EntityPropertyType;
+    description: string;
+}>;
+export interface EntityField<V = any> {
+    description: string;
+    value?: V;
+}
+export declare const EntityTypeTextFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>;
+export type EntityTextField = z.infer<typeof EntityTypeTextFieldSchema>;
+export declare const EntityTypeIntFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>;
+export type EntityIntField = z.infer<typeof EntityTypeIntFieldSchema>;
+export declare const EntityTypeFloatFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>;
+export type EntityFloatField = z.infer<typeof EntityTypeFloatFieldSchema>;
+export declare const EntityTypeBooleanFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>;
+export type EntityBooleanField = z.infer<typeof EntityTypeBooleanFieldSchema>;
+export declare const EntityTypeFieldSchema: z.ZodUnion<[z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>]>;
+export type SupportedEntityField = EntityTextField | EntityIntField | EntityFloatField | EntityBooleanField;
+export declare const EntityFields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>]>>;
+export declare const EntityTypeSchema: z.ZodObject<{
+    description: z.ZodDefault<z.ZodString>;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Text>;
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Int>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Float>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Boolean>;
+        value: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+}, {
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    description?: string | undefined;
+}>;
+export declare const EdgeTypeSchema: z.ZodObject<{
+    description: z.ZodDefault<z.ZodString>;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Text>;
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Int>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Float>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Boolean>;
+        value: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>]>>;
+} & {
+    sourceTargets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source?: string | undefined;
+        target?: string | undefined;
+    }, {
+        source?: string | undefined;
+        target?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    sourceTargets?: {
+        source?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+}, {
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    description?: string | undefined;
+    sourceTargets?: {
+        source?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+}>;
+export type EntityType = z.infer<typeof EntityTypeSchema>;
+export type EdgeType = z.infer<typeof EdgeTypeSchema>;
+export type EntityData<T extends EntityType> = {
+    [P in keyof T["fields"]]: T["fields"][P] extends {
+        value?: infer V;
+    } ? V : never;
+};
+export type EdgeData<T extends EdgeType> = {
+    [P in keyof T["fields"]]: T["fields"][P] extends {
+        value?: infer V;
+    } ? V : never;
+};
+export declare const entityFields: {
+    text: (description: string) => EntityTextField;
+    integer: (description: string) => EntityIntField;
+    float: (description: string) => EntityFloatField;
+    boolean: (description: string) => EntityBooleanField;
+};
+export declare function entityModelToAPISchema(entityType: EntityType, name: string): Zep.EntityType;
+export declare function edgeModelToAPISchema(entityType: EdgeType, name: string): Zep.EdgeType;