@getzep/zep-cloud 1.0.4 → 1.0.6

package/dist/wrapper/memory.js

@@ -0,0 +1,59 @@
+"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.Memory = void 0;
+const Client_1 = require("../api/resources/memory/client/Client");
+const extractor_1 = require("../extractor");
+class Memory extends Client_1.Memory {
+    /**
+     * Extracts data based on a given schema and session details, transforms it according to the defined Zod schemas, and returns the transformed results.
+     *
+     * This method parses the provided schema against defined Zod validation rules, sends a request to extract data, and then transforms
+     * the extracted data according to the schema's specified ZepDataType.
+     *
+     * @template T - A record type where each key corresponds to a field name and its value is an object specifying `zep_type` and `description`.
+     * @param {string} sessionId - The session identifier for which data needs to be extracted.
+     * @param {T} schema - An object mapping each field to its corresponding ZepDataType and description. Each field should use one of the predefined methods from `zepFields` to ensure it conforms to the expected data type and structure.
+     * @param {Omit<ExtractDataRequest, "modelSchema">} params - Additional parameters for the extraction request excluding the model schema.
+     * @param {BaseMemory.RequestOptions} [requestOptions] - Optional additional request options.
+     * @returns {Promise<Record<string, any>>} A promise that resolves to an object where each key corresponds to the original schema's keys and their parsed values from the extraction.
+     *
+     * @example
+     * const result = await client.memory.extract(
+     *     session_id,
+     *     {
+     *         shoeSize: zepFields.number("The Customer's shoe size"),
+     *         budget: zepFields.number("The Customer's budget for shoe purchase"),
+     *         favoriteBrand: zepFields.text("The Customer's favorite shoe brand. Just one brand, please!"),
+     *         conversationDate: zepFields.date("The date of the conversation. Use current date if not present"),
+     *         conversationDateTime: zepFields.dateTime("The date time of the conversation."),
+     *         formattedPrice: zepFields.regex("The formatted price of the shoe", /\$\d+\.\d{2}/),
+     *     },
+     *     { lastN: 20, validate: false, currentDateTime: new Date().toISOString() }
+     * );
+     */
+    extract(sessionId, schema, params, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validatedData = extractor_1.DataExtractorFields.parse(schema);
+            const result = yield this.extractData(sessionId, Object.assign(Object.assign({}, params), { modelSchema: JSON.stringify({ properties: validatedData }) }), requestOptions);
+            const transformedResult = {};
+            for (const key in schema) {
+                const schemaItem = extractor_1.schemas[schema[key].zep_type];
+                if (!schemaItem) {
+                    throw new Error(`Unsupported zep_type: ${schema[key].zep_type}`);
+                }
+                transformedResult[key] = schemaItem.parse(Object.assign(Object.assign({}, schema[key]), { value: result[key] })).value;
+            }
+            return transformedResult;
+        });
+    }
+}
+exports.Memory = Memory;

package/examples/memory/memory_example.ts

@@ -1,6 +1,6 @@
 import { v4 as uuidv4 } from "uuid";
 import { CreateUserRequest, Message, NotFoundError } from "../../src/api";
-import { ZepClient } from "../../src";
+import { ZepClient, zepFields } from "../../src";
 
 // @ts-ignore
 import { history } from "./chat_shoe_store_history";
@@ -171,8 +171,9 @@ async function main() {
         const searchText = "Name some books that are about dystopian futures.";
         console.debug("Searching memory...", searchText);
 
-        const searchResults = await client.memory.search(sessionID, {
-            metadata: {
+        const { results: searchResults } = await client.memory.searchSessions({
+            sessionIds: [sessionID],
+            recordFilter: {
                 where: {
                     and: [
                         {
@@ -188,7 +189,7 @@ async function main() {
             searchScope: "messages",
         });
 
-        searchResults.forEach((searchResult) => {
+        searchResults?.forEach((searchResult) => {
             console.debug("Search Result: ", JSON.stringify(searchResult.message));
             console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
         });
@@ -205,7 +206,8 @@ async function main() {
         const searchText = "Name some books that are about dystopian futures.";
         console.debug("Searching memory with MMR...", searchText);
 
-        const searchResults = await client.memory.search(sessionID, {
+        const { results: searchResults } = await client.memory.searchSessions({
+            sessionIds: [sessionID],
             text: searchText,
             searchType: "mmr",
             mmrLambda: 0.6,
@@ -213,7 +215,7 @@ async function main() {
             searchScope: "messages",
         });
 
-        searchResults.forEach((searchResult) => {
+        searchResults?.forEach((searchResult) => {
             console.debug("Search Result: ", JSON.stringify(searchResult.message));
             console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
         });
@@ -230,7 +232,8 @@ async function main() {
         const searchText = "Name some books that are about dystopian futures.";
         console.debug("Searching summaries with MMR...", searchText);
 
-        const searchResults = await client.memory.search(sessionID, {
+        const { results: searchResults } = await client.memory.searchSessions({
+            sessionIds: [sessionID],
             text: searchText,
             searchScope: "summary",
             searchType: "mmr",
@@ -238,7 +241,7 @@ async function main() {
             limit: 3,
         });
 
-        searchResults.forEach((searchResult) => {
+        searchResults?.forEach((searchResult) => {
             console.debug("Search Result: ", JSON.stringify(searchResult.summary));
             console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
         });
@@ -250,6 +253,22 @@ async function main() {
         }
     }
 
+    try {
+        const result = await client.memory.extract(
+            sessionID,
+            {
+                shoeSize: zepFields.number("The Customer's shoe size"),
+                budget: zepFields.number("The Customer's budget for shoe purchase"),
+                favoriteBrand: zepFields.text("The Customer's favorite shoe brand. Just one brand, please!"),
+                formattedPrice: zepFields.regex("The formatted price of the shoe", /\$\d+\.\d{2}/),
+            },
+            { lastN: 20, validate: false, currentDateTime: new Date().toISOString() }
+        );
+        console.log("Data Extraction Result", result);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
     // End session - this will trigger summarization and other background tasks on the completed session
     try {
         await client.memory.endSession(sessionID);

package/examples/memory/structured_data_extraction_example.ts

@@ -0,0 +1,34 @@
+import { ZepClient, zepFields } from "../../src";
+import { type ExtractedData } from "../../src/extractor";
+
+async function main() {
+    const projectApiKey = process.env.ZEP_API_KEY;
+    const sessionId = process.env.ZEP_SESSION_ID;
+    if (!sessionId) {
+        console.error("Please provide a session ID using the ZEP_SESSION_ID environment variable");
+        return;
+    }
+
+    const client = new ZepClient({
+        apiKey: projectApiKey,
+    });
+
+    const customerSchema = {
+        shoeSize: zepFields.number("The Customer's shoe size"),
+        budget: zepFields.number("The Customer's budget for shoe purchase"),
+        favoriteBrand: zepFields.text("The Customer's favorite shoe brand. Just one brand, please!"),
+        formattedPrice: zepFields.regex("The formatted price of the shoe", /\$\d+\.\d{2}/),
+    };
+
+    type Customer = ExtractedData<typeof customerSchema>;
+
+    const result: Customer = await client.memory.extract(sessionId, customerSchema, {
+        lastN: 20,
+        validate: false,
+        currentDateTime: new Date().toISOString(),
+    });
+
+    console.log("Data Extraction Result", result);
+}
+
+main();

package/extractor/base.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare enum ZepDataType {
+    ZepText = "ZepText",
+    ZepZipCode = "ZepZipCode",
+    ZepDate = "ZepDate",
+    ZepDateTime = "ZepDateTime",
+    ZepEmail = "ZepEmail",
+    ZepPhoneNumber = "ZepPhoneNumber",
+    ZepFloat = "ZepFloat",
+    ZepNumber = "ZepNumber",
+    ZepRegex = "ZepRegex"
+}
+export declare const BaseSchema: z.ZodObject<{
+    zep_type: z.ZodNativeEnum<typeof ZepDataType>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: ZepDataType;
+}, {
+    description: string;
+    zep_type: ZepDataType;
+}>;

package/extractor/base.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSchema = exports.ZepDataType = void 0;
+const zod_1 = require("zod");
+var ZepDataType;
+(function (ZepDataType) {
+    ZepDataType["ZepText"] = "ZepText";
+    ZepDataType["ZepZipCode"] = "ZepZipCode";
+    ZepDataType["ZepDate"] = "ZepDate";
+    ZepDataType["ZepDateTime"] = "ZepDateTime";
+    ZepDataType["ZepEmail"] = "ZepEmail";
+    ZepDataType["ZepPhoneNumber"] = "ZepPhoneNumber";
+    ZepDataType["ZepFloat"] = "ZepFloat";
+    ZepDataType["ZepNumber"] = "ZepNumber";
+    ZepDataType["ZepRegex"] = "ZepRegex";
+})(ZepDataType = exports.ZepDataType || (exports.ZepDataType = {}));
+exports.BaseSchema = zod_1.z.object({
+    zep_type: zod_1.z.nativeEnum(ZepDataType),
+    description: zod_1.z.string(),
+});

package/extractor/date.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { ZepDataType } from "./base";
+import { HasOptionalValue } from "./index";
+export declare const ZepDateSchema: z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<ZepDataType.ZepDate>, z.ZodLiteral<ZepDataType.ZepDateTime>]>;
+    value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodDate]>, Date, string | Date>>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: ZepDataType.ZepDate | ZepDataType.ZepDateTime;
+    value?: Date | undefined;
+}, {
+    description: string;
+    zep_type: ZepDataType.ZepDate | ZepDataType.ZepDateTime;
+    value?: string | Date | undefined;
+}>;
+export interface ZepDateField extends HasOptionalValue<Date> {
+    zep_type: ZepDataType.ZepDate | ZepDataType.ZepDateTime;
+    description: string;
+}
+export declare const zepDateField: (description: string) => ZepDateField;
+export declare const zepDateTimeField: (description: string) => ZepDateField;

package/extractor/date.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zepDateTimeField = exports.zepDateField = exports.ZepDateSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const stringToDateTransformer = zod_1.z.union([zod_1.z.string(), zod_1.z.date()]).transform((value, ctx) => {
+    if (typeof value === "string") {
+        return new Date(value);
+    }
+    return value;
+});
+exports.ZepDateSchema = base_1.BaseSchema.extend({
+    zep_type: zod_1.z.union([zod_1.z.literal(base_1.ZepDataType.ZepDate), zod_1.z.literal(base_1.ZepDataType.ZepDateTime)]),
+    value: stringToDateTransformer.optional(),
+});
+const zepDateField = (description) => {
+    return exports.ZepDateSchema.parse({
+        zep_type: base_1.ZepDataType.ZepDate,
+        description,
+    });
+};
+exports.zepDateField = zepDateField;
+const zepDateTimeField = (description) => {
+    return exports.ZepDateSchema.parse({
+        zep_type: base_1.ZepDataType.ZepDateTime,
+        description,
+    });
+};
+exports.zepDateTimeField = zepDateTimeField;

package/extractor/index.d.ts

@@ -0,0 +1,281 @@
+import { z } from "zod";
+import { ZepDateField } from "./date";
+import { ZepNumberField } from "./number";
+import { ZepTextField } from "./text";
+import { ZepRegexField } from "./regex";
+export declare const DataExtractorFields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepNumber>, z.ZodLiteral<import("./base").ZepDataType.ZepFloat>]>;
+    value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+    default: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+    value?: number | undefined;
+    default?: number | undefined;
+}, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+    value?: string | number | undefined;
+    default?: string | number | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepText>, z.ZodLiteral<import("./base").ZepDataType.ZepZipCode>, z.ZodLiteral<import("./base").ZepDataType.ZepEmail>, z.ZodLiteral<import("./base").ZepDataType.ZepPhoneNumber>]>;
+    value: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+    value?: string | undefined;
+    default?: string | undefined;
+}, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+    value?: string | undefined;
+    default?: string | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepDate>, z.ZodLiteral<import("./base").ZepDataType.ZepDateTime>]>;
+    value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodDate]>, Date, string | Date>>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+    value?: Date | undefined;
+}, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+    value?: string | Date | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodLiteral<import("./base").ZepDataType.ZepRegex>;
+    value: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodEffects<z.ZodString, string, string>;
+    default: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepRegex;
+    pattern: string;
+    value?: string | undefined;
+    default?: string | undefined;
+}, {
+    description: string;
+    zep_type: import("./base").ZepDataType.ZepRegex;
+    pattern: string;
+    value?: string | undefined;
+    default?: string | undefined;
+}>]>>;
+export declare type SupportedZepField = ZepNumberField | ZepDateField | ZepRegexField | ZepTextField;
+export interface HasOptionalValue<V = any> {
+    value?: V;
+}
+/**
+ * Extracts the data types from the fields defined in the schema T. Each field in T
+ * is expected to conform to the HasOptionalValue interface, which optionally includes
+ * a 'value' of type V. This type definition maps each field in T to its corresponding
+ * 'value' type, but since 'value' is optional, the resulting type for each field also
+ * includes 'undefined'.
+ *
+ * @template T - The schema object from which to extract data types. Each property of T
+ *               should implement the HasOptionalValue interface.
+ *
+ * @returns An object type with the same keys as T, but where the type of each key is
+ *          either the type of 'value' in the corresponding field of T or 'undefined'
+ *          if 'value' is optional.
+ *
+ * @example
+ * ```
+ * interface PersonSchema {
+ *   name: HasOptionalValue<string>; // ZepTextField
+ *   age: HasOptionalValue<number>; // ZepNumberField
+ * }
+ *
+ * type PersonData = ExtractedData<PersonSchema>;
+ * // PersonData would be equivalent to:
+ * // { name: string | undefined; age: number | undefined; }
+ * ```
+ * This example demonstrates how `ExtractedData` would transform a hypothetical `PersonSchema`
+ * into `PersonData`, clarifying how the types are derived and what to expect in the output.
+ */
+export declare type ExtractedData<T> = {
+    [P in keyof T]: T[P] extends HasOptionalValue<infer V> ? V | undefined : never;
+};
+export declare const schemas: {
+    ZepNumber: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepNumber>, z.ZodLiteral<import("./base").ZepDataType.ZepFloat>]>;
+        value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+        default: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+        value?: number | undefined;
+        default?: number | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+        value?: string | number | undefined;
+        default?: string | number | undefined;
+    }>;
+    ZepText: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepText>, z.ZodLiteral<import("./base").ZepDataType.ZepZipCode>, z.ZodLiteral<import("./base").ZepDataType.ZepEmail>, z.ZodLiteral<import("./base").ZepDataType.ZepPhoneNumber>]>;
+        value: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }>;
+    ZepZipCode: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepText>, z.ZodLiteral<import("./base").ZepDataType.ZepZipCode>, z.ZodLiteral<import("./base").ZepDataType.ZepEmail>, z.ZodLiteral<import("./base").ZepDataType.ZepPhoneNumber>]>;
+        value: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }>;
+    ZepDate: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepDate>, z.ZodLiteral<import("./base").ZepDataType.ZepDateTime>]>;
+        value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodDate]>, Date, string | Date>>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+        value?: Date | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+        value?: string | Date | undefined;
+    }>;
+    ZepDateTime: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepDate>, z.ZodLiteral<import("./base").ZepDataType.ZepDateTime>]>;
+        value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodDate]>, Date, string | Date>>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+        value?: Date | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepDate | import("./base").ZepDataType.ZepDateTime;
+        value?: string | Date | undefined;
+    }>;
+    ZepEmail: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepText>, z.ZodLiteral<import("./base").ZepDataType.ZepZipCode>, z.ZodLiteral<import("./base").ZepDataType.ZepEmail>, z.ZodLiteral<import("./base").ZepDataType.ZepPhoneNumber>]>;
+        value: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }>;
+    ZepPhoneNumber: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepText>, z.ZodLiteral<import("./base").ZepDataType.ZepZipCode>, z.ZodLiteral<import("./base").ZepDataType.ZepEmail>, z.ZodLiteral<import("./base").ZepDataType.ZepPhoneNumber>]>;
+        value: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepText | import("./base").ZepDataType.ZepZipCode | import("./base").ZepDataType.ZepEmail | import("./base").ZepDataType.ZepPhoneNumber;
+        value?: string | undefined;
+        default?: string | undefined;
+    }>;
+    ZepFloat: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodUnion<[z.ZodLiteral<import("./base").ZepDataType.ZepNumber>, z.ZodLiteral<import("./base").ZepDataType.ZepFloat>]>;
+        value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+        default: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+        value?: number | undefined;
+        default?: number | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepFloat | import("./base").ZepDataType.ZepNumber;
+        value?: string | number | undefined;
+        default?: string | number | undefined;
+    }>;
+    ZepRegex: z.ZodObject<z.objectUtil.extendShape<{
+        zep_type: z.ZodNativeEnum<typeof import("./base").ZepDataType>;
+        description: z.ZodString;
+    }, {
+        zep_type: z.ZodLiteral<import("./base").ZepDataType.ZepRegex>;
+        value: z.ZodOptional<z.ZodString>;
+        pattern: z.ZodEffects<z.ZodString, string, string>;
+        default: z.ZodOptional<z.ZodString>;
+    }>, "strip", z.ZodTypeAny, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepRegex;
+        pattern: string;
+        value?: string | undefined;
+        default?: string | undefined;
+    }, {
+        description: string;
+        zep_type: import("./base").ZepDataType.ZepRegex;
+        pattern: string;
+        value?: string | undefined;
+        default?: string | undefined;
+    }>;
+};
+export declare const zepFields: {
+    number: (description: string) => ZepNumberField;
+    text: (description: string) => ZepTextField;
+    zipCode: (description: string) => ZepTextField;
+    date: (description: string) => ZepDateField;
+    dateTime: (description: string) => ZepDateField;
+    email: (description: string) => ZepTextField;
+    phoneNumber: (description: string) => ZepTextField;
+    float: (description: string) => ZepNumberField;
+    regex: (description: string, pattern: RegExp) => ZepRegexField;
+};

package/extractor/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zepFields = exports.schemas = exports.DataExtractorFields = void 0;
+const zod_1 = require("zod");
+const date_1 = require("./date");
+const number_1 = require("./number");
+const text_1 = require("./text");
+const regex_1 = require("./regex");
+exports.DataExtractorFields = zod_1.z.record(zod_1.z.union([number_1.ZepNumberSchema, text_1.ZepTextSchema, date_1.ZepDateSchema, regex_1.ZepRegexSchema]));
+exports.schemas = {
+    ZepNumber: number_1.ZepNumberSchema,
+    ZepText: text_1.ZepTextSchema,
+    ZepZipCode: text_1.ZepTextSchema,
+    ZepDate: date_1.ZepDateSchema,
+    ZepDateTime: date_1.ZepDateSchema,
+    ZepEmail: text_1.ZepTextSchema,
+    ZepPhoneNumber: text_1.ZepTextSchema,
+    ZepFloat: number_1.ZepNumberSchema,
+    ZepRegex: regex_1.ZepRegexSchema,
+};
+exports.zepFields = {
+    number: number_1.zepNumberField,
+    text: text_1.zepTextField,
+    zipCode: text_1.zepZipcodeField,
+    date: date_1.zepDateField,
+    dateTime: date_1.zepDateTimeField,
+    email: text_1.zepEmailField,
+    phoneNumber: text_1.zepPhoneNumberField,
+    float: number_1.zepFloatField,
+    regex: regex_1.zepRegexField,
+};

package/extractor/number.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { ZepDataType } from "./base";
+import { HasOptionalValue } from "./index";
+export declare const ZepNumberSchema: z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<ZepDataType.ZepNumber>, z.ZodLiteral<ZepDataType.ZepFloat>]>;
+    value: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+    default: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: ZepDataType.ZepFloat | ZepDataType.ZepNumber;
+    value?: number | undefined;
+    default?: number | undefined;
+}, {
+    description: string;
+    zep_type: ZepDataType.ZepFloat | ZepDataType.ZepNumber;
+    value?: string | number | undefined;
+    default?: string | number | undefined;
+}>;
+export interface ZepNumberField extends HasOptionalValue<number> {
+    zep_type: ZepDataType.ZepNumber | ZepDataType.ZepFloat;
+    description: string;
+}
+export declare const zepNumberField: (description: string) => ZepNumberField;
+export declare const zepFloatField: (description: string) => ZepNumberField;

package/extractor/number.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zepFloatField = exports.zepNumberField = exports.ZepNumberSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const stringToNumberTransformer = zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).transform((value, ctx) => {
+    if (typeof value === "string") {
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: "Not a number",
+            });
+        }
+        return parsed;
+    }
+    return value;
+});
+exports.ZepNumberSchema = base_1.BaseSchema.extend({
+    zep_type: zod_1.z.union([zod_1.z.literal(base_1.ZepDataType.ZepNumber), zod_1.z.literal(base_1.ZepDataType.ZepFloat)]),
+    value: stringToNumberTransformer.optional(),
+    default: stringToNumberTransformer.optional(),
+});
+const zepNumberField = (description) => {
+    return exports.ZepNumberSchema.parse({
+        zep_type: base_1.ZepDataType.ZepNumber,
+        description,
+    });
+};
+exports.zepNumberField = zepNumberField;
+const zepFloatField = (description) => {
+    return exports.ZepNumberSchema.parse({
+        zep_type: base_1.ZepDataType.ZepFloat,
+        description,
+    });
+};
+exports.zepFloatField = zepFloatField;