@videre-ui/cli 0.0.1

package/node_modules/@videre-ui/core/node_modules/zod/src/v4/mini/tests/string.test.ts

@@ -0,0 +1,347 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/mini";
+
+const FAIL = { success: false };
+
+test("z.string", async () => {
+  const a = z.string();
+  expect(z.parse(a, "hello")).toEqual("hello");
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  type a = z.infer<typeof a>;
+  expectTypeOf<a>().toEqualTypeOf<string>();
+});
+
+// test("z.string with description", () => {
+//   const a = z.string({ description: "string description" });
+//   a._def;
+//   expect(a._def.description).toEqual("string description");
+// });
+
+test("z.string with custom error", () => {
+  const a = z.string({ error: () => "BAD" });
+  expect(z.safeParse(a, 123).error!.issues[0].message).toEqual("BAD");
+});
+
+test("inference in checks", () => {
+  const a = z.string().check(z.refine((val) => val.length));
+  z.parse(a, "___");
+  expect(() => z.parse(a, "")).toThrow();
+  const b = z.string().check(z.refine((val) => val.length));
+  z.parse(b, "___");
+  expect(() => z.parse(b, "")).toThrow();
+  const c = z.string().check(z.refine((val) => val.length));
+  z.parse(c, "___");
+  expect(() => z.parse(c, "")).toThrow();
+  const d = z.string().check(z.refine((val) => val.length));
+  z.parse(d, "___");
+  expect(() => z.parse(d, "")).toThrow();
+});
+
+test("z.string async", async () => {
+  // async
+  const a = z.string().check(z.refine(async (val) => val.length));
+  expect(await z.parseAsync(a, "___")).toEqual("___");
+  await expect(() => z.parseAsync(a, "")).rejects.toThrowError();
+});
+
+test("z.uuid", () => {
+  const a = z.uuid();
+  // parse uuid
+  z.parse(a, "550e8400-e29b-41d4-a716-446655440000");
+  z.parse(a, "550e8400-e29b-61d4-a716-446655440000");
+
+  // bad uuid
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+
+  const b = z.uuidv4();
+  z.parse(b, "550e8400-e29b-41d4-a716-446655440000");
+  expect(z.safeParse(b, "550e8400-e29b-61d4-a716-446655440000")).toMatchObject(FAIL);
+
+  const c = z.uuidv6();
+  z.parse(c, "550e8400-e29b-61d4-a716-446655440000");
+  expect(z.safeParse(c, "550e8400-e29b-41d4-a716-446655440000")).toMatchObject(FAIL);
+
+  const d = z.uuidv7();
+  z.parse(d, "550e8400-e29b-71d4-a716-446655440000");
+  expect(z.safeParse(d, "550e8400-e29b-41d4-a716-446655440000")).toMatchObject(FAIL);
+  expect(z.safeParse(d, "550e8400-e29b-61d4-a716-446655440000")).toMatchObject(FAIL);
+});
+
+test("z.email", () => {
+  const a = z.email();
+  expect(z.parse(a, "test@test.com")).toEqual("test@test.com");
+  expect(() => z.parse(a, "test")).toThrow();
+  expect(z.safeParse(a, "bad email", { error: () => "bad email" }).error!.issues[0].message).toEqual("bad email");
+
+  const b = z.email("bad email");
+  expect(z.safeParse(b, "bad email").error!.issues[0].message).toEqual("bad email");
+
+  const c = z.email({ error: "bad email" });
+  expect(z.safeParse(c, "bad email").error!.issues[0].message).toEqual("bad email");
+
+  const d = z.email({ error: () => "bad email" });
+  expect(z.safeParse(d, "bad email").error!.issues[0].message).toEqual("bad email");
+});
+
+test("z.url", () => {
+  const a = z.url();
+  // valid URLs
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(a.parse("ftp://example.com")).toEqual("ftp://example.com");
+  expect(a.parse("http://sub.example.com")).toEqual("http://sub.example.com");
+  expect(a.parse("https://example.com/path?query=123#fragment")).toEqual("https://example.com/path?query=123#fragment");
+  expect(a.parse("http://localhost")).toEqual("http://localhost");
+  expect(a.parse("https://localhost")).toEqual("https://localhost");
+  expect(a.parse("http://localhost:3000")).toEqual("http://localhost:3000");
+  expect(a.parse("https://localhost:3000")).toEqual("https://localhost:3000");
+
+  // test trimming
+  expect(a.parse("  http://example.com  ")).toEqual("http://example.com");
+  expect(a.parse("  http://example.com/")).toEqual("http://example.com/");
+  expect(a.parse("  http://example.com")).toEqual("http://example.com");
+  expect(a.parse("  http://example.com//")).toEqual("http://example.com//");
+
+  // invalid URLs
+  expect(() => a.parse("not-a-url")).toThrow();
+  // expect(() => a.parse("http:/example.com")).toThrow();
+  expect(() => a.parse("://example.com")).toThrow();
+  expect(() => a.parse("http://")).toThrow();
+  expect(() => a.parse("example.com")).toThrow();
+
+  // wrong type
+  expect(() => a.parse(123)).toThrow();
+  expect(() => a.parse(null)).toThrow();
+  expect(() => a.parse(undefined)).toThrow();
+});
+
+test("z.url with optional hostname regex", () => {
+  const a = z.url({ hostname: /example\.com$/ });
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://sub.example.com")).toEqual("https://sub.example.com");
+  expect(() => a.parse("http://examples.com")).toThrow();
+  expect(() => a.parse("http://example.org")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url - file urls", () => {
+  // file URLs
+  const a = z.url({ hostname: /.*/ }); // allow any hostname
+  expect(a.parse("file:///path/to/file.txt")).toEqual("file:///path/to/file.txt");
+  expect(a.parse("file:///C:/path/to/file.txt")).toEqual("file:///C:/path/to/file.txt");
+  expect(a.parse("file:///C:/path/to/file.txt?query=123#fragment")).toEqual(
+    "file:///C:/path/to/file.txt?query=123#fragment"
+  );
+});
+test("z.url with optional protocol regex", () => {
+  const a = z.url({ protocol: /^https?$/ });
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(() => a.parse("ftp://example.com")).toThrow();
+  expect(() => a.parse("mailto:example@example.com")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url with both hostname and protocol regexes", () => {
+  const a = z.url({ hostname: /example\.com$/, protocol: /^https$/ });
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(a.parse("https://sub.example.com")).toEqual("https://sub.example.com");
+  expect(() => a.parse("http://example.com")).toThrow();
+  expect(() => a.parse("https://example.org")).toThrow();
+  expect(() => a.parse("ftp://example.com")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url with invalid regex patterns", () => {
+  const a = z.url({ hostname: /a+$/, protocol: /^ftp$/ });
+  a.parse("ftp://a");
+  a.parse("ftp://aaaaaaaa");
+  expect(() => a.parse("http://aaa")).toThrow();
+  expect(() => a.parse("https://example.com")).toThrow();
+  expect(() => a.parse("ftp://asdfasdf")).toThrow();
+  expect(() => a.parse("ftp://invalid")).toThrow();
+});
+
+test("z.emoji", () => {
+  const a = z.emoji();
+  expect(z.parse(a, "😀")).toEqual("😀");
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+test("z.nanoid", () => {
+  const a = z.nanoid();
+  expect(z.parse(a, "8FHZpIxleEK3axQRBNNjN")).toEqual("8FHZpIxleEK3axQRBNNjN");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.cuid", () => {
+  const a = z.cuid();
+  expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.cuid2", () => {
+  const a = z.cuid2();
+  expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.ulid", () => {
+  const a = z.ulid();
+  expect(z.parse(a, "01ETGRM9QYVX6S9V2F3B6JXG4N")).toEqual("01ETGRM9QYVX6S9V2F3B6JXG4N");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.xid", () => {
+  const a = z.xid();
+  expect(z.parse(a, "9m4e2mr0ui3e8a215n4g")).toEqual("9m4e2mr0ui3e8a215n4g");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.ksuid", () => {
+  const a = z.ksuid();
+  expect(z.parse(a, "2naeRjTrrHJAkfd3tOuEjw90WCA")).toEqual("2naeRjTrrHJAkfd3tOuEjw90WCA");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+// test("z.ip", () => {
+//   const a = z.ip();
+//   expect(z.parse(a, "127.0.0.1")).toEqual("127.0.0.1");
+//   expect(z.parse(a, "2001:0db8:85a3:0000:0000:8a2e:0370:7334")).toEqual("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
+//   expect(() => z.parse(a, "abc")).toThrow();
+// });
+
+test("z.ipv4", () => {
+  const a = z.ipv4();
+  // valid ipv4
+  expect(z.parse(a, "192.168.1.1")).toEqual("192.168.1.1");
+  expect(z.parse(a, "255.255.255.255")).toEqual("255.255.255.255");
+  // invalid ipv4
+  expect(() => z.parse(a, "999.999.999.999")).toThrow();
+  expect(() => z.parse(a, "256.256.256.256")).toThrow();
+  expect(() => z.parse(a, "192.168.1")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.ipv6", () => {
+  const a = z.ipv6();
+  // valid ipv6
+  expect(z.parse(a, "2001:0db8:85a3:0000:0000:8a2e:0370:7334")).toEqual("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
+  expect(z.parse(a, "::1")).toEqual("::1");
+  // invalid ipv6
+  expect(() => z.parse(a, "2001:db8::85a3::8a2e:370:7334")).toThrow();
+  expect(() => z.parse(a, "2001:db8:85a3:0:0:8a2e:370g:7334")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.mac", () => {
+  const a = z.mac();
+  // valid mac
+  expect(z.parse(a, "00:1A:2B:3C:4D:5E")).toEqual("00:1A:2B:3C:4D:5E");
+  // invalid mac (dash delimiter not accepted by default)
+  expect(() => z.parse(a, "01-23-45-67-89-AB")).toThrow();
+  expect(() => z.parse(a, "00:1A:2B::4D:5E")).toThrow();
+  expect(() => z.parse(a, "00:1a-2B:3c-4D:5e")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.mac with custom delimiter", () => {
+  const a = z.mac({ delimiter: ":" });
+  // valid mac with colon
+  expect(z.parse(a, "00:1A:2B:3C:4D:5E")).toEqual("00:1A:2B:3C:4D:5E");
+  // invalid mac with dash
+  expect(() => z.parse(a, "00-1A-2B-3C-4D-5E")).toThrow();
+
+  const b = z.mac({ delimiter: "-" });
+  // valid mac with dash
+  expect(z.parse(b, "00-1A-2B-3C-4D-5E")).toEqual("00-1A-2B-3C-4D-5E");
+  // invalid mac with colon
+  expect(() => z.parse(b, "00:1A:2B:3C:4D:5E")).toThrow();
+
+  const c = z.mac({ delimiter: ":" });
+  // colon-only mac
+  expect(z.parse(c, "00:1A:2B:3C:4D:5E")).toEqual("00:1A:2B:3C:4D:5E");
+  expect(() => z.parse(c, "00-1A-2B-3C-4D-5E")).toThrow();
+});
+
+test("z.base64", () => {
+  const a = z.base64();
+  // valid base64
+  expect(z.parse(a, "SGVsbG8gd29ybGQ=")).toEqual("SGVsbG8gd29ybGQ=");
+  expect(z.parse(a, "U29tZSBvdGhlciBzdHJpbmc=")).toEqual("U29tZSBvdGhlciBzdHJpbmc=");
+  // invalid base64
+  expect(() => z.parse(a, "SGVsbG8gd29ybGQ")).toThrow();
+  expect(() => z.parse(a, "U29tZSBvdGhlciBzdHJpbmc")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+// test("z.jsonString", () => {
+//   const a = z.jsonString();
+//   // valid JSON string
+//   expect(z.parse(a, '{"key":"value"}')).toEqual('{"key":"value"}');
+//   expect(z.parse(a, '["item1", "item2"]')).toEqual('["item1", "item2"]');
+//   // invalid JSON string
+//   expect(() => z.parse(a, '{"key":value}')).toThrow();
+//   expect(() => z.parse(a, '["item1", "item2"')).toThrow();
+//   expect(() => z.parse(a, "hello")).toThrow();
+//   // wrong type
+//   expect(() => z.parse(a, 123)).toThrow();
+// });
+
+test("z.e164", () => {
+  const a = z.e164();
+  // valid e164
+  expect(z.parse(a, "+1234567890")).toEqual("+1234567890");
+  expect(z.parse(a, "+19876543210")).toEqual("+19876543210");
+  // invalid e164
+  expect(() => z.parse(a, "1234567890")).toThrow();
+  expect(() => z.parse(a, "+12345")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.jwt", () => {
+  const a = z.jwt();
+  // valid jwt
+  expect(
+    z.parse(
+      a,
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+    )
+  ).toEqual(
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+  );
+  // invalid jwt
+  expect(() => z.parse(a, "invalid.jwt.token")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.hash generic format", () => {
+  expect(z.hash("sha256").parse("a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3")).toBe(
+    "a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3"
+  );
+
+  // --- Type-level checks (ensure the literal format string is encoded in the return type)
+  expectTypeOf(z.hash("md5")).toEqualTypeOf<z.ZodMiniCustomStringFormat<"md5_hex">>();
+  expectTypeOf(z.hash("sha1")).toEqualTypeOf<z.ZodMiniCustomStringFormat<"sha1_hex">>();
+  expectTypeOf(z.hash("sha256", { enc: "base64" as const })).toEqualTypeOf<
+    z.ZodMiniCustomStringFormat<"sha256_base64">
+  >();
+  expectTypeOf(z.hash("sha384", { enc: "base64url" as const })).toEqualTypeOf<
+    z.ZodMiniCustomStringFormat<"sha384_base64url">
+  >();
+});

package/node_modules/@videre-ui/core/node_modules/zod/src/v4-mini/index.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/node_modules/@videre-ui/core/node_modules/zod/v3/ZodError.cjs

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const util_js_1 = require("./helpers/util.cjs");
+exports.ZodIssueCode = util_js_1.util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+};
+exports.quotelessJson = quotelessJson;
+class ZodError extends Error {
+    get errors() {
+        return this.issues;
+    }
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            // eslint-disable-next-line ban/ban
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util_js_1.util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = Object.create(null);
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                const firstEl = sub.path[0];
+                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+                fieldErrors[firstEl].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+exports.ZodError = ZodError;
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};

package/node_modules/@videre-ui/core/node_modules/zod/v3/ZodError.d.cts

@@ -0,0 +1,164 @@
+import type { Primitive } from "./helpers/typeAliases.cjs";
+import { util, type ZodParsedType } from "./helpers/util.cjs";
+import type { TypeOf, ZodType } from "./index.cjs";
+type allKeys<T> = T extends any ? keyof T : never;
+export type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export type typeToFlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<T>]?: U[];
+    };
+};
+export declare const ZodIssueCode: {
+    custom: "custom";
+    invalid_type: "invalid_type";
+    too_big: "too_big";
+    too_small: "too_small";
+    not_multiple_of: "not_multiple_of";
+    unrecognized_keys: "unrecognized_keys";
+    invalid_union: "invalid_union";
+    invalid_literal: "invalid_literal";
+    invalid_union_discriminator: "invalid_union_discriminator";
+    invalid_enum_value: "invalid_enum_value";
+    invalid_arguments: "invalid_arguments";
+    invalid_return_type: "invalid_return_type";
+    invalid_date: "invalid_date";
+    invalid_string: "invalid_string";
+    invalid_intersection_types: "invalid_intersection_types";
+    not_finite: "not_finite";
+};
+export type ZodIssueCode = keyof typeof ZodIssueCode;
+export type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string | undefined;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+export type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+    includes: string;
+    position?: number | undefined;
+} | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number | bigint;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+export type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+export type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean | undefined;
+    message: string;
+};
+export declare const quotelessJson: (obj: any) => string;
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? {
+    [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown;
+export type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+export type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+export declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format(): ZodFormattedError<T>;
+    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    static assert(value: unknown): asserts value is ZodError;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten(): typeToFlattenedError<T>;
+    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+    get formErrors(): typeToFlattenedError<T, string>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean | undefined;
+};
+export type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+export type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+export {};