@fonoster/common 0.8.25 → 0.8.27

package/dist/assistants/index.js

@@ -0,0 +1,39 @@
+"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 });
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./tools"), exports);
+__exportStar(require("./assistantSchema"), exports);
+__exportStar(require("./LanguageModelProvider"), exports);
+__exportStar(require("./conversationSettingsSchema"), exports);
+__exportStar(require("./languageModelConfigSchema"), exports);

package/dist/assistants/languageModelConfigSchema.d.ts

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { LanguageModelProvider } from "./LanguageModelProvider";
+declare const languageModelConfigSchema: z.ZodObject<{
+    provider: z.ZodNativeEnum<typeof LanguageModelProvider>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+    temperature: z.ZodNumber;
+    maxTokens: z.ZodNumber;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    knowledgeBase: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["s3"]>;
+        title: z.ZodString;
+        document: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "s3";
+        title?: string;
+        document?: string;
+    }, {
+        type?: "s3";
+        title?: string;
+        document?: string;
+    }>, "many">;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodObject<{
+            type: z.ZodEnum<["object", "array"]>;
+            properties: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+                type: z.ZodString;
+                format: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        }, {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        }>;
+        requestStartMessage: z.ZodOptional<z.ZodString>;
+        operation: z.ZodEffects<z.ZodObject<{
+            type: z.ZodNativeEnum<typeof import("./tools/AllowedOperations").AllowedOperations>;
+            url: z.ZodOptional<z.ZodString>;
+            waitForResponse: z.ZodOptional<z.ZodBoolean>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        }, {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        }>, {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        }, {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        parameters?: {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        };
+        requestStartMessage?: string;
+        operation?: {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        };
+    }, {
+        name?: string;
+        description?: string;
+        parameters?: {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        };
+        requestStartMessage?: string;
+        operation?: {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    provider?: LanguageModelProvider;
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    baseUrl?: string;
+    knowledgeBase?: {
+        type?: "s3";
+        title?: string;
+        document?: string;
+    }[];
+    tools?: {
+        name?: string;
+        description?: string;
+        parameters?: {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        };
+        requestStartMessage?: string;
+        operation?: {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        };
+    }[];
+}, {
+    provider?: LanguageModelProvider;
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    baseUrl?: string;
+    knowledgeBase?: {
+        type?: "s3";
+        title?: string;
+        document?: string;
+    }[];
+    tools?: {
+        name?: string;
+        description?: string;
+        parameters?: {
+            type?: "object" | "array";
+            properties?: Record<string, {
+                type?: string;
+                format?: string;
+                pattern?: string;
+            }>;
+            required?: string[];
+        };
+        requestStartMessage?: string;
+        operation?: {
+            type?: import("./tools/AllowedOperations").AllowedOperations;
+            url?: string;
+            waitForResponse?: boolean;
+            headers?: Record<string, string>;
+        };
+    }[];
+}>;
+export { languageModelConfigSchema };

package/dist/assistants/languageModelConfigSchema.js

@@ -0,0 +1,89 @@
+"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 __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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languageModelConfigSchema = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+const tools_1 = require("./tools");
+const LanguageModelProvider_1 = require("./LanguageModelProvider");
+const Messages = __importStar(require("../messages"));
+const NUMBER_BETWEEN_0_AND_2 = "Must be a number between 0 and 2";
+const languageModelConfigSchema = zod_1.z.object({
+    provider: zod_1.z.nativeEnum(LanguageModelProvider_1.LanguageModelProvider, {
+        message: "Invalid language model provider."
+    }),
+    apiKey: zod_1.z.string().optional(),
+    model: zod_1.z.string(),
+    temperature: zod_1.z
+        .number()
+        .max(2, { message: NUMBER_BETWEEN_0_AND_2 })
+        .min(0, { message: NUMBER_BETWEEN_0_AND_2 }),
+    maxTokens: zod_1.z
+        .number()
+        .int({ message: Messages.POSITIVE_INTEGER_MESSAGE })
+        .positive({ message: Messages.POSITIVE_INTEGER_MESSAGE }),
+    baseUrl: zod_1.z
+        .string()
+        .url({
+        message: Messages.VALID_URL
+    })
+        .optional(),
+    knowledgeBase: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.enum(["s3"]),
+        title: zod_1.z.string(),
+        document: zod_1.z.string().regex(/\.pdf$/, {
+            message: "Document must be a pdf file"
+        })
+    })),
+    tools: zod_1.z.array(tools_1.toolSchema)
+});
+exports.languageModelConfigSchema = languageModelConfigSchema;

package/dist/assistants/tools/AllowedOperations.d.ts

@@ -0,0 +1,6 @@
+declare enum AllowedOperations {
+    GET = "get",
+    POST = "post",
+    BUILT_IN = "built-in"
+}
+export { AllowedOperations };

package/dist/assistants/tools/AllowedOperations.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowedOperations = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var AllowedOperations;
+(function (AllowedOperations) {
+    AllowedOperations["GET"] = "get";
+    AllowedOperations["POST"] = "post";
+    AllowedOperations["BUILT_IN"] = "built-in";
+})(AllowedOperations || (exports.AllowedOperations = AllowedOperations = {}));

package/dist/assistants/tools/index.d.ts

@@ -0,0 +1 @@
+export * from "./toolSchema";

package/dist/assistants/tools/index.js

@@ -0,0 +1,35 @@
+"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 });
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./toolSchema"), exports);

package/dist/assistants/tools/propertySchema.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+declare const propertySchema: z.ZodEffects<z.ZodObject<{
+    type: z.ZodString;
+    format: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: string;
+    format?: string;
+    pattern?: string;
+}, {
+    type?: string;
+    format?: string;
+    pattern?: string;
+}>, {
+    type?: string;
+    format?: string;
+    pattern?: string;
+}, {
+    type?: string;
+    format?: string;
+    pattern?: string;
+}>;
+export { propertySchema };

package/dist/assistants/tools/propertySchema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertySchema = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+const propertySchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+    format: zod_1.z.string().optional(),
+    pattern: zod_1.z.string().optional()
+})
+    .refine((data) => {
+    return !("format" in data && "pattern" in data);
+}, {
+    message: "Property can only have either 'format' or 'pattern', not both."
+});
+exports.propertySchema = propertySchema;

package/dist/assistants/tools/toolSchema.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { AllowedOperations } from "./AllowedOperations";
+declare const toolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodObject<{
+        type: z.ZodEnum<["object", "array"]>;
+        properties: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+            type: z.ZodString;
+            format: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "object" | "array";
+        properties?: Record<string, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>;
+        required?: string[];
+    }, {
+        type?: "object" | "array";
+        properties?: Record<string, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>;
+        required?: string[];
+    }>;
+    requestStartMessage: z.ZodOptional<z.ZodString>;
+    operation: z.ZodEffects<z.ZodObject<{
+        type: z.ZodNativeEnum<typeof AllowedOperations>;
+        url: z.ZodOptional<z.ZodString>;
+        waitForResponse: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    }, {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    }>, {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    }, {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    description?: string;
+    parameters?: {
+        type?: "object" | "array";
+        properties?: Record<string, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>;
+        required?: string[];
+    };
+    requestStartMessage?: string;
+    operation?: {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    };
+}, {
+    name?: string;
+    description?: string;
+    parameters?: {
+        type?: "object" | "array";
+        properties?: Record<string, {
+            type?: string;
+            format?: string;
+            pattern?: string;
+        }>;
+        required?: string[];
+    };
+    requestStartMessage?: string;
+    operation?: {
+        type?: AllowedOperations;
+        url?: string;
+        waitForResponse?: boolean;
+        headers?: Record<string, string>;
+    };
+}>;
+export { toolSchema };

package/dist/assistants/tools/toolSchema.js

@@ -0,0 +1,87 @@
+"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 __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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolSchema = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+const propertySchema_1 = require("./propertySchema");
+const Messages = __importStar(require("../../messages"));
+const AllowedOperations_1 = require("./AllowedOperations");
+const toolSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    parameters: zod_1.z.object({
+        type: zod_1.z.enum(["object", "array"]),
+        properties: zod_1.z.record(propertySchema_1.propertySchema),
+        required: zod_1.z.array(zod_1.z.string()).optional()
+    }),
+    requestStartMessage: zod_1.z.string().optional(),
+    operation: zod_1.z
+        .object({
+        type: zod_1.z.nativeEnum(AllowedOperations_1.AllowedOperations, {
+            message: "Invalid operation type"
+        }),
+        // Make url required if operation type is not built-in
+        url: zod_1.z.string().url({ message: Messages.VALID_URL }).optional(),
+        waitForResponse: zod_1.z.boolean().optional(),
+        headers: zod_1.z.record(zod_1.z.string()).optional()
+    })
+        .superRefine(({ url, type }, ctx) => {
+        if (type !== AllowedOperations_1.AllowedOperations.BUILT_IN && !url) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: "Url is required for non built-in operations."
+            });
+        }
+    })
+});
+exports.toolSchema = toolSchema;

package/dist/errors/PrismaErrorEnum.d.ts

@@ -1,6 +1,5 @@
 declare enum PrismaErrorEnum {
     RECORD_ALREADY_EXISTS = "P2002",
-    RECORD_NOT_FOUND = "P2025",
-    FAILED_PRECONDITION = "P2003"
+    RECORD_NOT_FOUND = "P2025"
 }
 export { PrismaErrorEnum };

package/dist/errors/PrismaErrorEnum.js

@@ -23,5 +23,4 @@ var PrismaErrorEnum;
 (function (PrismaErrorEnum) {
     PrismaErrorEnum["RECORD_ALREADY_EXISTS"] = "P2002";
     PrismaErrorEnum["RECORD_NOT_FOUND"] = "P2025";
-    PrismaErrorEnum["FAILED_PRECONDITION"] = "P2003";
 })(PrismaErrorEnum || (exports.PrismaErrorEnum = PrismaErrorEnum = {}));