@getzep/zep-cloud 1.0.4 → 1.0.5

package/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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;

package/dist/extractor/regex.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { ZepDataType } from "./base";
+import { HasOptionalValue } from "./index";
+export declare const ZepRegexSchema: z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodLiteral<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: ZepDataType.ZepRegex;
+    pattern: string;
+    value?: string | undefined;
+    default?: string | undefined;
+}, {
+    description: string;
+    zep_type: ZepDataType.ZepRegex;
+    pattern: string;
+    value?: string | undefined;
+    default?: string | undefined;
+}>;
+export interface ZepRegexField extends HasOptionalValue<string> {
+    zep_type: ZepDataType.ZepRegex;
+    description: string;
+    pattern: string;
+}
+export declare const zepRegexField: (description: string, pattern: RegExp) => ZepRegexField;

package/dist/extractor/regex.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zepRegexField = exports.ZepRegexSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+exports.ZepRegexSchema = base_1.BaseSchema.extend({
+    zep_type: zod_1.z.literal(base_1.ZepDataType.ZepRegex),
+    value: zod_1.z.string().optional(),
+    pattern: zod_1.z.string().refine((p) => {
+        try {
+            new RegExp(p);
+            return true; // Pattern is valid
+        }
+        catch (_a) {
+            return false; // Pattern is invalid
+        }
+    }, {
+        message: "Invalid regex pattern", // Custom error message
+    }),
+    default: zod_1.z.string().optional(),
+});
+const zepRegexField = (description, pattern) => {
+    return exports.ZepRegexSchema.parse({
+        zep_type: base_1.ZepDataType.ZepRegex,
+        pattern: pattern.source,
+        description,
+    });
+};
+exports.zepRegexField = zepRegexField;

package/dist/extractor/text.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { ZepDataType } from "./base";
+import { HasOptionalValue } from "./index";
+export declare const ZepTextSchema: z.ZodObject<z.objectUtil.extendShape<{
+    zep_type: z.ZodNativeEnum<typeof ZepDataType>;
+    description: z.ZodString;
+}, {
+    zep_type: z.ZodUnion<[z.ZodLiteral<ZepDataType.ZepText>, z.ZodLiteral<ZepDataType.ZepZipCode>, z.ZodLiteral<ZepDataType.ZepEmail>, z.ZodLiteral<ZepDataType.ZepPhoneNumber>]>;
+    value: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    zep_type: ZepDataType.ZepText | ZepDataType.ZepZipCode | ZepDataType.ZepEmail | ZepDataType.ZepPhoneNumber;
+    value?: string | undefined;
+    default?: string | undefined;
+}, {
+    description: string;
+    zep_type: ZepDataType.ZepText | ZepDataType.ZepZipCode | ZepDataType.ZepEmail | ZepDataType.ZepPhoneNumber;
+    value?: string | undefined;
+    default?: string | undefined;
+}>;
+export interface ZepTextField extends HasOptionalValue<string> {
+    zep_type: ZepDataType.ZepText | ZepDataType.ZepZipCode | ZepDataType.ZepEmail | ZepDataType.ZepPhoneNumber;
+    description: string;
+}
+export declare const zepTextField: (description: string) => ZepTextField;
+export declare const zepZipcodeField: (description: string) => ZepTextField;
+export declare const zepPhoneNumberField: (description: string) => ZepTextField;
+export declare const zepEmailField: (description: string) => ZepTextField;

package/dist/extractor/text.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zepEmailField = exports.zepPhoneNumberField = exports.zepZipcodeField = exports.zepTextField = exports.ZepTextSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+exports.ZepTextSchema = base_1.BaseSchema.extend({
+    zep_type: zod_1.z.union([
+        zod_1.z.literal(base_1.ZepDataType.ZepText),
+        zod_1.z.literal(base_1.ZepDataType.ZepZipCode),
+        zod_1.z.literal(base_1.ZepDataType.ZepEmail),
+        zod_1.z.literal(base_1.ZepDataType.ZepPhoneNumber),
+    ]),
+    value: zod_1.z.string().optional(),
+    default: zod_1.z.string().optional(),
+});
+const zepTextField = (description) => {
+    return exports.ZepTextSchema.parse({
+        zep_type: base_1.ZepDataType.ZepText,
+        description,
+    });
+};
+exports.zepTextField = zepTextField;
+const zepZipcodeField = (description) => {
+    return exports.ZepTextSchema.parse({
+        zep_type: base_1.ZepDataType.ZepZipCode,
+        description,
+    });
+};
+exports.zepZipcodeField = zepZipcodeField;
+const zepPhoneNumberField = (description) => {
+    return exports.ZepTextSchema.parse({
+        zep_type: base_1.ZepDataType.ZepPhoneNumber,
+        description,
+    });
+};
+exports.zepPhoneNumberField = zepPhoneNumberField;
+const zepEmailField = (description) => {
+    return exports.ZepTextSchema.parse({
+        zep_type: base_1.ZepDataType.ZepEmail,
+        description,
+    });
+};
+exports.zepEmailField = zepEmailField;

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * as Zep from "./api";
 export { ZepClient } from "./wrapper";
 export { ZepEnvironment } from "./environments";
 export { ZepError, ZepTimeoutError } from "./errors";
+export { zepFields } from "./extractor";

package/dist/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZepTimeoutError = exports.ZepError = exports.ZepEnvironment = exports.ZepClient = exports.Zep = void 0;
+exports.zepFields = exports.ZepTimeoutError = exports.ZepError = exports.ZepEnvironment = exports.ZepClient = exports.Zep = void 0;
 exports.Zep = __importStar(require("./api"));
 var wrapper_1 = require("./wrapper");
 Object.defineProperty(exports, "ZepClient", { enumerable: true, get: function () { return wrapper_1.ZepClient; } });
@@ -32,3 +32,5 @@ Object.defineProperty(exports, "ZepEnvironment", { enumerable: true, get: functi
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "ZepError", { enumerable: true, get: function () { return errors_1.ZepError; } });
 Object.defineProperty(exports, "ZepTimeoutError", { enumerable: true, get: function () { return errors_1.ZepTimeoutError; } });
+var extractor_1 = require("./extractor");
+Object.defineProperty(exports, "zepFields", { enumerable: true, get: function () { return extractor_1.zepFields; } });

package/dist/serialization/resources/memory/client/extractData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../index";
+import * as core from "../../../../core";
+export declare const Response: core.serialization.Schema<serializers.memory.extractData.Response.Raw, Record<string, string>>;
+export declare namespace Response {
+    type Raw = Record<string, string>;
+}

package/dist/serialization/resources/memory/client/extractData.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const core = __importStar(require("../../../../core"));
+exports.Response = core.serialization.record(core.serialization.string(), core.serialization.string());

package/dist/serialization/resources/memory/client/index.d.ts

@@ -1,2 +1,3 @@
+export * as extractData from "./extractData";
 export * as search from "./search";
 export * from "./requests";