drizzle-kit 0.20.16 → 0.20.17-0d9aa5f

package/utils-studio.js

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -355,30 +356,30 @@ var init_supports_color = __esm({
 
 // node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
+  let index4 = string.indexOf(substring);
+  if (index4 === -1) {
     return string;
   }
   const substringLength = substring.length;
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
+    returnValue += string.slice(endIndex, index4) + substring + replacer;
+    endIndex = index4 + substringLength;
+    index4 = string.indexOf(substring, endIndex);
+  } while (index4 !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index4) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
+    const gotCR = string[index4 - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index4 - 1 : index4) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index4 + 1;
+    index4 = string.indexOf("\n", endIndex);
+  } while (index4 !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
@@ -1054,7 +1055,7 @@ var require_hanji = __commonJS({
       return;
     }
     exports.render = render2;
-    function renderWithTask3(view, task) {
+    function renderWithTask2(view, task) {
       return __awaiter(this, void 0, void 0, function* () {
         const terminal = new TaskTerminal(view, process.stdout);
         terminal.requestLayout();
@@ -1063,7 +1064,7 @@ var require_hanji = __commonJS({
         return result;
       });
     }
-    exports.renderWithTask = renderWithTask3;
+    exports.renderWithTask = renderWithTask2;
     var terminateHandler;
     function onTerminate(callback) {
       terminateHandler = callback;
@@ -1072,12 +1073,3696 @@ var require_hanji = __commonJS({
   }
 });
 
+// src/global.ts
+var originUUID, snapshotVersion;
+var init_global = __esm({
+  "src/global.ts"() {
+    "use strict";
+    originUUID = "00000000-0000-0000-0000-000000000000";
+    snapshotVersion = "6";
+  }
+});
+
+// node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
+function getErrorMap() {
+  return overrideErrorMap;
+}
+function addIssueToContext(ctx, issueData) {
+  const issue = makeIssue({
+    issueData,
+    data: ctx.data,
+    path: ctx.path,
+    errorMaps: [
+      ctx.common.contextualErrorMap,
+      ctx.schemaErrorMap,
+      getErrorMap(),
+      errorMap
+      // then global default map
+    ].filter((x) => !!x)
+  });
+  ctx.common.issues.push(issue);
+}
+function processCreateParams(params) {
+  if (!params)
+    return {};
+  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
+  if (errorMap2 && (invalid_type_error || required_error)) {
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  }
+  if (errorMap2)
+    return { errorMap: errorMap2, description };
+  const customMap = (iss, ctx) => {
+    if (iss.code !== "invalid_type")
+      return { message: ctx.defaultError };
+    if (typeof ctx.data === "undefined") {
+      return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+    }
+    return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
+  };
+  return { errorMap: customMap, description };
+}
+function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
+  return valInt % stepInt / Math.pow(10, decCount);
+}
+function deepPartialify(schema3) {
+  if (schema3 instanceof ZodObject) {
+    const newShape = {};
+    for (const key in schema3.shape) {
+      const fieldSchema = schema3.shape[key];
+      newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
+    }
+    return new ZodObject({
+      ...schema3._def,
+      shape: () => newShape
+    });
+  } else if (schema3 instanceof ZodArray) {
+    return ZodArray.create(deepPartialify(schema3.element));
+  } else if (schema3 instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema3.unwrap()));
+  } else if (schema3 instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema3.unwrap()));
+  } else if (schema3 instanceof ZodTuple) {
+    return ZodTuple.create(schema3.items.map((item) => deepPartialify(item)));
+  } else {
+    return schema3;
+  }
+}
+function mergeValues(a, b) {
+  const aType = getParsedType(a);
+  const bType = getParsedType(b);
+  if (a === b) {
+    return { valid: true, data: a };
+  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
+    const bKeys = util.objectKeys(b);
+    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const newObj = { ...a, ...b };
+    for (const key of sharedKeys) {
+      const sharedValue = mergeValues(a[key], b[key]);
+      if (!sharedValue.valid) {
+        return { valid: false };
+      }
+      newObj[key] = sharedValue.data;
+    }
+    return { valid: true, data: newObj };
+  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
+    if (a.length !== b.length) {
+      return { valid: false };
+    }
+    const newArray = [];
+    for (let index4 = 0; index4 < a.length; index4++) {
+      const itemA = a[index4];
+      const itemB = b[index4];
+      const sharedValue = mergeValues(itemA, itemB);
+      if (!sharedValue.valid) {
+        return { valid: false };
+      }
+      newArray.push(sharedValue.data);
+    }
+    return { valid: true, data: newArray };
+  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
+    return { valid: true, data: a };
+  } else {
+    return { valid: false };
+  }
+}
+function createZodEnum(values, params) {
+  return new ZodEnum({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodEnum,
+    ...processCreateParams(params)
+  });
+}
+var util, ZodParsedType, getParsedType, ZodIssueCode, ZodError, errorMap, overrideErrorMap, makeIssue, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync, errorUtil, ParseInputLazyPath, handleResult, ZodType, cuidRegex, uuidRegex, emailRegex, datetimeRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, objectUtil, AugmentFactory, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, late, ZodFirstPartyTypeKind, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType;
+var init_lib = __esm({
+  "node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs"() {
+    (function(util2) {
+      util2.assertEqual = (val) => val;
+      function assertIs(_arg) {
+      }
+      util2.assertIs = assertIs;
+      function assertNever(_x) {
+        throw new Error();
+      }
+      util2.assertNever = assertNever;
+      util2.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+          obj[item] = item;
+        }
+        return obj;
+      };
+      util2.getValidEnumValues = (obj) => {
+        const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+          filtered[k] = obj[k];
+        }
+        return util2.objectValues(filtered);
+      };
+      util2.objectValues = (obj) => {
+        return util2.objectKeys(obj).map(function(e) {
+          return obj[e];
+        });
+      };
+      util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+        const keys = [];
+        for (const key in object) {
+          if (Object.prototype.hasOwnProperty.call(object, key)) {
+            keys.push(key);
+          }
+        }
+        return keys;
+      };
+      util2.find = (arr, checker) => {
+        for (const item of arr) {
+          if (checker(item))
+            return item;
+        }
+        return void 0;
+      };
+      util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+      function joinValues(array, separator = " | ") {
+        return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+      }
+      util2.joinValues = joinValues;
+      util2.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+          return value.toString();
+        }
+        return value;
+      };
+    })(util || (util = {}));
+    ZodParsedType = util.arrayToEnum([
+      "string",
+      "nan",
+      "number",
+      "integer",
+      "float",
+      "boolean",
+      "date",
+      "bigint",
+      "symbol",
+      "function",
+      "undefined",
+      "null",
+      "array",
+      "object",
+      "unknown",
+      "promise",
+      "void",
+      "never",
+      "map",
+      "set"
+    ]);
+    getParsedType = (data) => {
+      const t = typeof data;
+      switch (t) {
+        case "undefined":
+          return ZodParsedType.undefined;
+        case "string":
+          return ZodParsedType.string;
+        case "number":
+          return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+        case "boolean":
+          return ZodParsedType.boolean;
+        case "function":
+          return ZodParsedType.function;
+        case "bigint":
+          return ZodParsedType.bigint;
+        case "symbol":
+          return ZodParsedType.symbol;
+        case "object":
+          if (Array.isArray(data)) {
+            return ZodParsedType.array;
+          }
+          if (data === null) {
+            return ZodParsedType.null;
+          }
+          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+            return ZodParsedType.promise;
+          }
+          if (typeof Map !== "undefined" && data instanceof Map) {
+            return ZodParsedType.map;
+          }
+          if (typeof Set !== "undefined" && data instanceof Set) {
+            return ZodParsedType.set;
+          }
+          if (typeof Date !== "undefined" && data instanceof Date) {
+            return ZodParsedType.date;
+          }
+          return ZodParsedType.object;
+        default:
+          return ZodParsedType.unknown;
+      }
+    };
+    ZodIssueCode = 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"
+    ]);
+    ZodError = class extends Error {
+      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) {
+          Object.setPrototypeOf(this, actualProto);
+        } else {
+          this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+      }
+      get errors() {
+        return this.issues;
+      }
+      format(_mapper) {
+        const mapper = _mapper || function(issue) {
+          return issue.message;
+        };
+        const fieldErrors = { _errors: [] };
+        const processError = (error2) => {
+          for (const issue of error2.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: [] };
+                } else {
+                  curr[el] = curr[el] || { _errors: [] };
+                  curr[el]._errors.push(mapper(issue));
+                }
+                curr = curr[el];
+                i++;
+              }
+            }
+          }
+        };
+        processError(this);
+        return fieldErrors;
+      }
+      toString() {
+        return this.message;
+      }
+      get message() {
+        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+      }
+      get isEmpty() {
+        return this.issues.length === 0;
+      }
+      flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+          if (sub.path.length > 0) {
+            fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+            fieldErrors[sub.path[0]].push(mapper(sub));
+          } else {
+            formErrors.push(mapper(sub));
+          }
+        }
+        return { formErrors, fieldErrors };
+      }
+      get formErrors() {
+        return this.flatten();
+      }
+    };
+    ZodError.create = (issues) => {
+      const error2 = new ZodError(issues);
+      return error2;
+    };
+    errorMap = (issue, _ctx) => {
+      let message;
+      switch (issue.code) {
+        case ZodIssueCode.invalid_type:
+          if (issue.received === ZodParsedType.undefined) {
+            message = "Required";
+          } else {
+            message = `Expected ${issue.expected}, received ${issue.received}`;
+          }
+          break;
+        case ZodIssueCode.invalid_literal:
+          message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+          break;
+        case ZodIssueCode.unrecognized_keys:
+          message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+          break;
+        case ZodIssueCode.invalid_union:
+          message = `Invalid input`;
+          break;
+        case ZodIssueCode.invalid_union_discriminator:
+          message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+          break;
+        case ZodIssueCode.invalid_enum_value:
+          message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+          break;
+        case ZodIssueCode.invalid_arguments:
+          message = `Invalid function arguments`;
+          break;
+        case ZodIssueCode.invalid_return_type:
+          message = `Invalid function return type`;
+          break;
+        case ZodIssueCode.invalid_date:
+          message = `Invalid date`;
+          break;
+        case ZodIssueCode.invalid_string:
+          if (typeof issue.validation === "object") {
+            if ("startsWith" in issue.validation) {
+              message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+            } else if ("endsWith" in issue.validation) {
+              message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+            } else {
+              util.assertNever(issue.validation);
+            }
+          } else if (issue.validation !== "regex") {
+            message = `Invalid ${issue.validation}`;
+          } else {
+            message = "Invalid";
+          }
+          break;
+        case ZodIssueCode.too_small:
+          if (issue.type === "array")
+            message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+          else if (issue.type === "string")
+            message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+          else if (issue.type === "number")
+            message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+          else if (issue.type === "date")
+            message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(issue.minimum)}`;
+          else
+            message = "Invalid input";
+          break;
+        case ZodIssueCode.too_big:
+          if (issue.type === "array")
+            message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+          else if (issue.type === "string")
+            message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+          else if (issue.type === "number")
+            message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+          else if (issue.type === "date")
+            message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(issue.maximum)}`;
+          else
+            message = "Invalid input";
+          break;
+        case ZodIssueCode.custom:
+          message = `Invalid input`;
+          break;
+        case ZodIssueCode.invalid_intersection_types:
+          message = `Intersection results could not be merged`;
+          break;
+        case ZodIssueCode.not_multiple_of:
+          message = `Number must be a multiple of ${issue.multipleOf}`;
+          break;
+        case ZodIssueCode.not_finite:
+          message = "Number must be finite";
+          break;
+        default:
+          message = _ctx.defaultError;
+          util.assertNever(issue);
+      }
+      return { message };
+    };
+    overrideErrorMap = errorMap;
+    makeIssue = (params) => {
+      const { data, path: path2, errorMaps, issueData } = params;
+      const fullPath = [...path2, ...issueData.path || []];
+      const fullIssue = {
+        ...issueData,
+        path: fullPath
+      };
+      let errorMessage = "";
+      const maps = errorMaps.filter((m) => !!m).slice().reverse();
+      for (const map of maps) {
+        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+      }
+      return {
+        ...issueData,
+        path: fullPath,
+        message: issueData.message || errorMessage
+      };
+    };
+    ParseStatus = class _ParseStatus {
+      constructor() {
+        this.value = "valid";
+      }
+      dirty() {
+        if (this.value === "valid")
+          this.value = "dirty";
+      }
+      abort() {
+        if (this.value !== "aborted")
+          this.value = "aborted";
+      }
+      static mergeArray(status, results) {
+        const arrayValue = [];
+        for (const s of results) {
+          if (s.status === "aborted")
+            return INVALID;
+          if (s.status === "dirty")
+            status.dirty();
+          arrayValue.push(s.value);
+        }
+        return { status: status.value, value: arrayValue };
+      }
+      static async mergeObjectAsync(status, pairs) {
+        const syncPairs = [];
+        for (const pair of pairs) {
+          syncPairs.push({
+            key: await pair.key,
+            value: await pair.value
+          });
+        }
+        return _ParseStatus.mergeObjectSync(status, syncPairs);
+      }
+      static mergeObjectSync(status, pairs) {
+        const finalObject = {};
+        for (const pair of pairs) {
+          const { key, value } = pair;
+          if (key.status === "aborted")
+            return INVALID;
+          if (value.status === "aborted")
+            return INVALID;
+          if (key.status === "dirty")
+            status.dirty();
+          if (value.status === "dirty")
+            status.dirty();
+          if (typeof value.value !== "undefined" || pair.alwaysSet) {
+            finalObject[key.value] = value.value;
+          }
+        }
+        return { status: status.value, value: finalObject };
+      }
+    };
+    INVALID = Object.freeze({
+      status: "aborted"
+    });
+    DIRTY = (value) => ({ status: "dirty", value });
+    OK = (value) => ({ status: "valid", value });
+    isAborted = (x) => x.status === "aborted";
+    isDirty = (x) => x.status === "dirty";
+    isValid = (x) => x.status === "valid";
+    isAsync = (x) => typeof Promise !== void 0 && x instanceof Promise;
+    (function(errorUtil2) {
+      errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+      errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+    })(errorUtil || (errorUtil = {}));
+    ParseInputLazyPath = class {
+      constructor(parent, value, path2, key) {
+        this.parent = parent;
+        this.data = value;
+        this._path = path2;
+        this._key = key;
+      }
+      get path() {
+        return this._path.concat(this._key);
+      }
+    };
+    handleResult = (ctx, result) => {
+      if (isValid(result)) {
+        return { success: true, data: result.value };
+      } else {
+        if (!ctx.common.issues.length) {
+          throw new Error("Validation failed but no issues detected.");
+        }
+        const error2 = new ZodError(ctx.common.issues);
+        return { success: false, error: error2 };
+      }
+    };
+    ZodType = class {
+      constructor(def) {
+        this.spa = this.safeParseAsync;
+        this._def = def;
+        this.parse = this.parse.bind(this);
+        this.safeParse = this.safeParse.bind(this);
+        this.parseAsync = this.parseAsync.bind(this);
+        this.safeParseAsync = this.safeParseAsync.bind(this);
+        this.spa = this.spa.bind(this);
+        this.refine = this.refine.bind(this);
+        this.refinement = this.refinement.bind(this);
+        this.superRefine = this.superRefine.bind(this);
+        this.optional = this.optional.bind(this);
+        this.nullable = this.nullable.bind(this);
+        this.nullish = this.nullish.bind(this);
+        this.array = this.array.bind(this);
+        this.promise = this.promise.bind(this);
+        this.or = this.or.bind(this);
+        this.and = this.and.bind(this);
+        this.transform = this.transform.bind(this);
+        this.brand = this.brand.bind(this);
+        this.default = this.default.bind(this);
+        this.catch = this.catch.bind(this);
+        this.describe = this.describe.bind(this);
+        this.pipe = this.pipe.bind(this);
+        this.isNullable = this.isNullable.bind(this);
+        this.isOptional = this.isOptional.bind(this);
+      }
+      get description() {
+        return this._def.description;
+      }
+      _getType(input) {
+        return getParsedType(input.data);
+      }
+      _getOrReturnCtx(input, ctx) {
+        return ctx || {
+          common: input.parent.common,
+          data: input.data,
+          parsedType: getParsedType(input.data),
+          schemaErrorMap: this._def.errorMap,
+          path: input.path,
+          parent: input.parent
+        };
+      }
+      _processInputParams(input) {
+        return {
+          status: new ParseStatus(),
+          ctx: {
+            common: input.parent.common,
+            data: input.data,
+            parsedType: getParsedType(input.data),
+            schemaErrorMap: this._def.errorMap,
+            path: input.path,
+            parent: input.parent
+          }
+        };
+      }
+      _parseSync(input) {
+        const result = this._parse(input);
+        if (isAsync(result)) {
+          throw new Error("Synchronous parse encountered promise.");
+        }
+        return result;
+      }
+      _parseAsync(input) {
+        const result = this._parse(input);
+        return Promise.resolve(result);
+      }
+      parse(data, params) {
+        const result = this.safeParse(data, params);
+        if (result.success)
+          return result.data;
+        throw result.error;
+      }
+      safeParse(data, params) {
+        var _a;
+        const ctx = {
+          common: {
+            issues: [],
+            async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
+            contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
+          },
+          path: (params === null || params === void 0 ? void 0 : params.path) || [],
+          schemaErrorMap: this._def.errorMap,
+          parent: null,
+          data,
+          parsedType: getParsedType(data)
+        };
+        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+        return handleResult(ctx, result);
+      }
+      async parseAsync(data, params) {
+        const result = await this.safeParseAsync(data, params);
+        if (result.success)
+          return result.data;
+        throw result.error;
+      }
+      async safeParseAsync(data, params) {
+        const ctx = {
+          common: {
+            issues: [],
+            contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+            async: true
+          },
+          path: (params === null || params === void 0 ? void 0 : params.path) || [],
+          schemaErrorMap: this._def.errorMap,
+          parent: null,
+          data,
+          parsedType: getParsedType(data)
+        };
+        const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
+        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+        return handleResult(ctx, result);
+      }
+      refine(check, message) {
+        const getIssueProperties = (val) => {
+          if (typeof message === "string" || typeof message === "undefined") {
+            return { message };
+          } else if (typeof message === "function") {
+            return message(val);
+          } else {
+            return message;
+          }
+        };
+        return this._refinement((val, ctx) => {
+          const result = check(val);
+          const setError = () => ctx.addIssue({
+            code: ZodIssueCode.custom,
+            ...getIssueProperties(val)
+          });
+          if (typeof Promise !== "undefined" && result instanceof Promise) {
+            return result.then((data) => {
+              if (!data) {
+                setError();
+                return false;
+              } else {
+                return true;
+              }
+            });
+          }
+          if (!result) {
+            setError();
+            return false;
+          } else {
+            return true;
+          }
+        });
+      }
+      refinement(check, refinementData) {
+        return this._refinement((val, ctx) => {
+          if (!check(val)) {
+            ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+            return false;
+          } else {
+            return true;
+          }
+        });
+      }
+      _refinement(refinement) {
+        return new ZodEffects({
+          schema: this,
+          typeName: ZodFirstPartyTypeKind.ZodEffects,
+          effect: { type: "refinement", refinement }
+        });
+      }
+      superRefine(refinement) {
+        return this._refinement(refinement);
+      }
+      optional() {
+        return ZodOptional.create(this);
+      }
+      nullable() {
+        return ZodNullable.create(this);
+      }
+      nullish() {
+        return this.optional().nullable();
+      }
+      array() {
+        return ZodArray.create(this);
+      }
+      promise() {
+        return ZodPromise.create(this);
+      }
+      or(option) {
+        return ZodUnion.create([this, option]);
+      }
+      and(incoming) {
+        return ZodIntersection.create(this, incoming);
+      }
+      transform(transform) {
+        return new ZodEffects({
+          schema: this,
+          typeName: ZodFirstPartyTypeKind.ZodEffects,
+          effect: { type: "transform", transform }
+        });
+      }
+      default(def) {
+        const defaultValueFunc = typeof def === "function" ? def : () => def;
+        return new ZodDefault({
+          innerType: this,
+          defaultValue: defaultValueFunc,
+          typeName: ZodFirstPartyTypeKind.ZodDefault
+        });
+      }
+      brand() {
+        return new ZodBranded({
+          typeName: ZodFirstPartyTypeKind.ZodBranded,
+          type: this,
+          ...processCreateParams(void 0)
+        });
+      }
+      catch(def) {
+        const defaultValueFunc = typeof def === "function" ? def : () => def;
+        return new ZodCatch({
+          innerType: this,
+          defaultValue: defaultValueFunc,
+          typeName: ZodFirstPartyTypeKind.ZodCatch
+        });
+      }
+      describe(description) {
+        const This = this.constructor;
+        return new This({
+          ...this._def,
+          description
+        });
+      }
+      pipe(target) {
+        return ZodPipeline.create(this, target);
+      }
+      isOptional() {
+        return this.safeParse(void 0).success;
+      }
+      isNullable() {
+        return this.safeParse(null).success;
+      }
+    };
+    cuidRegex = /^c[^\s-]{8,}$/i;
+    uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
+    emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+    datetimeRegex = (args) => {
+      if (args.precision) {
+        if (args.offset) {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}:\\d{2})|Z)$`);
+        } else {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
+        }
+      } else if (args.precision === 0) {
+        if (args.offset) {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}:\\d{2})|Z)$`);
+        } else {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
+        }
+      } else {
+        if (args.offset) {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}:\\d{2})|Z)$`);
+        } else {
+          return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
+        }
+      }
+    };
+    ZodString = class _ZodString extends ZodType {
+      constructor() {
+        super(...arguments);
+        this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), {
+          validation,
+          code: ZodIssueCode.invalid_string,
+          ...errorUtil.errToObj(message)
+        });
+        this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
+        this.trim = () => new _ZodString({
+          ...this._def,
+          checks: [...this._def.checks, { kind: "trim" }]
+        });
+      }
+      _parse(input) {
+        if (this._def.coerce) {
+          input.data = String(input.data);
+        }
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.string) {
+          const ctx2 = this._getOrReturnCtx(input);
+          addIssueToContext(
+            ctx2,
+            {
+              code: ZodIssueCode.invalid_type,
+              expected: ZodParsedType.string,
+              received: ctx2.parsedType
+            }
+            //
+          );
+          return INVALID;
+        }
+        const status = new ParseStatus();
+        let ctx = void 0;
+        for (const check of this._def.checks) {
+          if (check.kind === "min") {
+            if (input.data.length < check.value) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_small,
+                minimum: check.value,
+                type: "string",
+                inclusive: true,
+                exact: false,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "max") {
+            if (input.data.length > check.value) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_big,
+                maximum: check.value,
+                type: "string",
+                inclusive: true,
+                exact: false,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "length") {
+            const tooBig = input.data.length > check.value;
+            const tooSmall = input.data.length < check.value;
+            if (tooBig || tooSmall) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              if (tooBig) {
+                addIssueToContext(ctx, {
+                  code: ZodIssueCode.too_big,
+                  maximum: check.value,
+                  type: "string",
+                  inclusive: true,
+                  exact: true,
+                  message: check.message
+                });
+              } else if (tooSmall) {
+                addIssueToContext(ctx, {
+                  code: ZodIssueCode.too_small,
+                  minimum: check.value,
+                  type: "string",
+                  inclusive: true,
+                  exact: true,
+                  message: check.message
+                });
+              }
+              status.dirty();
+            }
+          } else if (check.kind === "email") {
+            if (!emailRegex.test(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                validation: "email",
+                code: ZodIssueCode.invalid_string,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "uuid") {
+            if (!uuidRegex.test(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                validation: "uuid",
+                code: ZodIssueCode.invalid_string,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "cuid") {
+            if (!cuidRegex.test(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                validation: "cuid",
+                code: ZodIssueCode.invalid_string,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "url") {
+            try {
+              new URL(input.data);
+            } catch (_a) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                validation: "url",
+                code: ZodIssueCode.invalid_string,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "regex") {
+            check.regex.lastIndex = 0;
+            const testResult = check.regex.test(input.data);
+            if (!testResult) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                validation: "regex",
+                code: ZodIssueCode.invalid_string,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "trim") {
+            input.data = input.data.trim();
+          } else if (check.kind === "startsWith") {
+            if (!input.data.startsWith(check.value)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.invalid_string,
+                validation: { startsWith: check.value },
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "endsWith") {
+            if (!input.data.endsWith(check.value)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.invalid_string,
+                validation: { endsWith: check.value },
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "datetime") {
+            const regex = datetimeRegex(check);
+            if (!regex.test(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.invalid_string,
+                validation: "datetime",
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else {
+            util.assertNever(check);
+          }
+        }
+        return { status: status.value, value: input.data };
+      }
+      _addCheck(check) {
+        return new _ZodString({
+          ...this._def,
+          checks: [...this._def.checks, check]
+        });
+      }
+      email(message) {
+        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
+      }
+      url(message) {
+        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
+      }
+      uuid(message) {
+        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
+      }
+      cuid(message) {
+        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
+      }
+      datetime(options) {
+        var _a;
+        if (typeof options === "string") {
+          return this._addCheck({
+            kind: "datetime",
+            precision: null,
+            offset: false,
+            message: options
+          });
+        }
+        return this._addCheck({
+          kind: "datetime",
+          precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
+          offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
+          ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
+        });
+      }
+      regex(regex, message) {
+        return this._addCheck({
+          kind: "regex",
+          regex,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      startsWith(value, message) {
+        return this._addCheck({
+          kind: "startsWith",
+          value,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      endsWith(value, message) {
+        return this._addCheck({
+          kind: "endsWith",
+          value,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      min(minLength, message) {
+        return this._addCheck({
+          kind: "min",
+          value: minLength,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      max(maxLength, message) {
+        return this._addCheck({
+          kind: "max",
+          value: maxLength,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      length(len, message) {
+        return this._addCheck({
+          kind: "length",
+          value: len,
+          ...errorUtil.errToObj(message)
+        });
+      }
+      get isDatetime() {
+        return !!this._def.checks.find((ch) => ch.kind === "datetime");
+      }
+      get isEmail() {
+        return !!this._def.checks.find((ch) => ch.kind === "email");
+      }
+      get isURL() {
+        return !!this._def.checks.find((ch) => ch.kind === "url");
+      }
+      get isUUID() {
+        return !!this._def.checks.find((ch) => ch.kind === "uuid");
+      }
+      get isCUID() {
+        return !!this._def.checks.find((ch) => ch.kind === "cuid");
+      }
+      get minLength() {
+        let min = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "min") {
+            if (min === null || ch.value > min)
+              min = ch.value;
+          }
+        }
+        return min;
+      }
+      get maxLength() {
+        let max = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "max") {
+            if (max === null || ch.value < max)
+              max = ch.value;
+          }
+        }
+        return max;
+      }
+    };
+    ZodString.create = (params) => {
+      var _a;
+      return new ZodString({
+        checks: [],
+        typeName: ZodFirstPartyTypeKind.ZodString,
+        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        ...processCreateParams(params)
+      });
+    };
+    ZodNumber = class _ZodNumber extends ZodType {
+      constructor() {
+        super(...arguments);
+        this.min = this.gte;
+        this.max = this.lte;
+        this.step = this.multipleOf;
+      }
+      _parse(input) {
+        if (this._def.coerce) {
+          input.data = Number(input.data);
+        }
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.number) {
+          const ctx2 = this._getOrReturnCtx(input);
+          addIssueToContext(ctx2, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.number,
+            received: ctx2.parsedType
+          });
+          return INVALID;
+        }
+        let ctx = void 0;
+        const status = new ParseStatus();
+        for (const check of this._def.checks) {
+          if (check.kind === "int") {
+            if (!util.isInteger(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.invalid_type,
+                expected: "integer",
+                received: "float",
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "min") {
+            const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+            if (tooSmall) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_small,
+                minimum: check.value,
+                type: "number",
+                inclusive: check.inclusive,
+                exact: false,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "max") {
+            const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+            if (tooBig) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_big,
+                maximum: check.value,
+                type: "number",
+                inclusive: check.inclusive,
+                exact: false,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "multipleOf") {
+            if (floatSafeRemainder(input.data, check.value) !== 0) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.not_multiple_of,
+                multipleOf: check.value,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "finite") {
+            if (!Number.isFinite(input.data)) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.not_finite,
+                message: check.message
+              });
+              status.dirty();
+            }
+          } else {
+            util.assertNever(check);
+          }
+        }
+        return { status: status.value, value: input.data };
+      }
+      gte(value, message) {
+        return this.setLimit("min", value, true, errorUtil.toString(message));
+      }
+      gt(value, message) {
+        return this.setLimit("min", value, false, errorUtil.toString(message));
+      }
+      lte(value, message) {
+        return this.setLimit("max", value, true, errorUtil.toString(message));
+      }
+      lt(value, message) {
+        return this.setLimit("max", value, false, errorUtil.toString(message));
+      }
+      setLimit(kind, value, inclusive, message) {
+        return new _ZodNumber({
+          ...this._def,
+          checks: [
+            ...this._def.checks,
+            {
+              kind,
+              value,
+              inclusive,
+              message: errorUtil.toString(message)
+            }
+          ]
+        });
+      }
+      _addCheck(check) {
+        return new _ZodNumber({
+          ...this._def,
+          checks: [...this._def.checks, check]
+        });
+      }
+      int(message) {
+        return this._addCheck({
+          kind: "int",
+          message: errorUtil.toString(message)
+        });
+      }
+      positive(message) {
+        return this._addCheck({
+          kind: "min",
+          value: 0,
+          inclusive: false,
+          message: errorUtil.toString(message)
+        });
+      }
+      negative(message) {
+        return this._addCheck({
+          kind: "max",
+          value: 0,
+          inclusive: false,
+          message: errorUtil.toString(message)
+        });
+      }
+      nonpositive(message) {
+        return this._addCheck({
+          kind: "max",
+          value: 0,
+          inclusive: true,
+          message: errorUtil.toString(message)
+        });
+      }
+      nonnegative(message) {
+        return this._addCheck({
+          kind: "min",
+          value: 0,
+          inclusive: true,
+          message: errorUtil.toString(message)
+        });
+      }
+      multipleOf(value, message) {
+        return this._addCheck({
+          kind: "multipleOf",
+          value,
+          message: errorUtil.toString(message)
+        });
+      }
+      finite(message) {
+        return this._addCheck({
+          kind: "finite",
+          message: errorUtil.toString(message)
+        });
+      }
+      get minValue() {
+        let min = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "min") {
+            if (min === null || ch.value > min)
+              min = ch.value;
+          }
+        }
+        return min;
+      }
+      get maxValue() {
+        let max = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "max") {
+            if (max === null || ch.value < max)
+              max = ch.value;
+          }
+        }
+        return max;
+      }
+      get isInt() {
+        return !!this._def.checks.find((ch) => ch.kind === "int");
+      }
+    };
+    ZodNumber.create = (params) => {
+      return new ZodNumber({
+        checks: [],
+        typeName: ZodFirstPartyTypeKind.ZodNumber,
+        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        ...processCreateParams(params)
+      });
+    };
+    ZodBigInt = class extends ZodType {
+      _parse(input) {
+        if (this._def.coerce) {
+          input.data = BigInt(input.data);
+        }
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.bigint) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.bigint,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodBigInt.create = (params) => {
+      var _a;
+      return new ZodBigInt({
+        typeName: ZodFirstPartyTypeKind.ZodBigInt,
+        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        ...processCreateParams(params)
+      });
+    };
+    ZodBoolean = class extends ZodType {
+      _parse(input) {
+        if (this._def.coerce) {
+          input.data = Boolean(input.data);
+        }
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.boolean) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.boolean,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodBoolean.create = (params) => {
+      return new ZodBoolean({
+        typeName: ZodFirstPartyTypeKind.ZodBoolean,
+        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        ...processCreateParams(params)
+      });
+    };
+    ZodDate = class _ZodDate extends ZodType {
+      _parse(input) {
+        if (this._def.coerce) {
+          input.data = new Date(input.data);
+        }
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.date) {
+          const ctx2 = this._getOrReturnCtx(input);
+          addIssueToContext(ctx2, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.date,
+            received: ctx2.parsedType
+          });
+          return INVALID;
+        }
+        if (isNaN(input.data.getTime())) {
+          const ctx2 = this._getOrReturnCtx(input);
+          addIssueToContext(ctx2, {
+            code: ZodIssueCode.invalid_date
+          });
+          return INVALID;
+        }
+        const status = new ParseStatus();
+        let ctx = void 0;
+        for (const check of this._def.checks) {
+          if (check.kind === "min") {
+            if (input.data.getTime() < check.value) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_small,
+                message: check.message,
+                inclusive: true,
+                exact: false,
+                minimum: check.value,
+                type: "date"
+              });
+              status.dirty();
+            }
+          } else if (check.kind === "max") {
+            if (input.data.getTime() > check.value) {
+              ctx = this._getOrReturnCtx(input, ctx);
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.too_big,
+                message: check.message,
+                inclusive: true,
+                exact: false,
+                maximum: check.value,
+                type: "date"
+              });
+              status.dirty();
+            }
+          } else {
+            util.assertNever(check);
+          }
+        }
+        return {
+          status: status.value,
+          value: new Date(input.data.getTime())
+        };
+      }
+      _addCheck(check) {
+        return new _ZodDate({
+          ...this._def,
+          checks: [...this._def.checks, check]
+        });
+      }
+      min(minDate, message) {
+        return this._addCheck({
+          kind: "min",
+          value: minDate.getTime(),
+          message: errorUtil.toString(message)
+        });
+      }
+      max(maxDate, message) {
+        return this._addCheck({
+          kind: "max",
+          value: maxDate.getTime(),
+          message: errorUtil.toString(message)
+        });
+      }
+      get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "min") {
+            if (min === null || ch.value > min)
+              min = ch.value;
+          }
+        }
+        return min != null ? new Date(min) : null;
+      }
+      get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+          if (ch.kind === "max") {
+            if (max === null || ch.value < max)
+              max = ch.value;
+          }
+        }
+        return max != null ? new Date(max) : null;
+      }
+    };
+    ZodDate.create = (params) => {
+      return new ZodDate({
+        checks: [],
+        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        typeName: ZodFirstPartyTypeKind.ZodDate,
+        ...processCreateParams(params)
+      });
+    };
+    ZodSymbol = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.symbol) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.symbol,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodSymbol.create = (params) => {
+      return new ZodSymbol({
+        typeName: ZodFirstPartyTypeKind.ZodSymbol,
+        ...processCreateParams(params)
+      });
+    };
+    ZodUndefined = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.undefined) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.undefined,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodUndefined.create = (params) => {
+      return new ZodUndefined({
+        typeName: ZodFirstPartyTypeKind.ZodUndefined,
+        ...processCreateParams(params)
+      });
+    };
+    ZodNull = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.null) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.null,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodNull.create = (params) => {
+      return new ZodNull({
+        typeName: ZodFirstPartyTypeKind.ZodNull,
+        ...processCreateParams(params)
+      });
+    };
+    ZodAny = class extends ZodType {
+      constructor() {
+        super(...arguments);
+        this._any = true;
+      }
+      _parse(input) {
+        return OK(input.data);
+      }
+    };
+    ZodAny.create = (params) => {
+      return new ZodAny({
+        typeName: ZodFirstPartyTypeKind.ZodAny,
+        ...processCreateParams(params)
+      });
+    };
+    ZodUnknown = class extends ZodType {
+      constructor() {
+        super(...arguments);
+        this._unknown = true;
+      }
+      _parse(input) {
+        return OK(input.data);
+      }
+    };
+    ZodUnknown.create = (params) => {
+      return new ZodUnknown({
+        typeName: ZodFirstPartyTypeKind.ZodUnknown,
+        ...processCreateParams(params)
+      });
+    };
+    ZodNever = class extends ZodType {
+      _parse(input) {
+        const ctx = this._getOrReturnCtx(input);
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.invalid_type,
+          expected: ZodParsedType.never,
+          received: ctx.parsedType
+        });
+        return INVALID;
+      }
+    };
+    ZodNever.create = (params) => {
+      return new ZodNever({
+        typeName: ZodFirstPartyTypeKind.ZodNever,
+        ...processCreateParams(params)
+      });
+    };
+    ZodVoid = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.undefined) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.void,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+    };
+    ZodVoid.create = (params) => {
+      return new ZodVoid({
+        typeName: ZodFirstPartyTypeKind.ZodVoid,
+        ...processCreateParams(params)
+      });
+    };
+    ZodArray = class _ZodArray extends ZodType {
+      _parse(input) {
+        const { ctx, status } = this._processInputParams(input);
+        const def = this._def;
+        if (ctx.parsedType !== ZodParsedType.array) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.array,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        if (def.exactLength !== null) {
+          const tooBig = ctx.data.length > def.exactLength.value;
+          const tooSmall = ctx.data.length < def.exactLength.value;
+          if (tooBig || tooSmall) {
+            addIssueToContext(ctx, {
+              code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
+              minimum: tooSmall ? def.exactLength.value : void 0,
+              maximum: tooBig ? def.exactLength.value : void 0,
+              type: "array",
+              inclusive: true,
+              exact: true,
+              message: def.exactLength.message
+            });
+            status.dirty();
+          }
+        }
+        if (def.minLength !== null) {
+          if (ctx.data.length < def.minLength.value) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_small,
+              minimum: def.minLength.value,
+              type: "array",
+              inclusive: true,
+              exact: false,
+              message: def.minLength.message
+            });
+            status.dirty();
+          }
+        }
+        if (def.maxLength !== null) {
+          if (ctx.data.length > def.maxLength.value) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_big,
+              maximum: def.maxLength.value,
+              type: "array",
+              inclusive: true,
+              exact: false,
+              message: def.maxLength.message
+            });
+            status.dirty();
+          }
+        }
+        if (ctx.common.async) {
+          return Promise.all(ctx.data.map((item, i) => {
+            return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+          })).then((result2) => {
+            return ParseStatus.mergeArray(status, result2);
+          });
+        }
+        const result = ctx.data.map((item, i) => {
+          return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+        });
+        return ParseStatus.mergeArray(status, result);
+      }
+      get element() {
+        return this._def.type;
+      }
+      min(minLength, message) {
+        return new _ZodArray({
+          ...this._def,
+          minLength: { value: minLength, message: errorUtil.toString(message) }
+        });
+      }
+      max(maxLength, message) {
+        return new _ZodArray({
+          ...this._def,
+          maxLength: { value: maxLength, message: errorUtil.toString(message) }
+        });
+      }
+      length(len, message) {
+        return new _ZodArray({
+          ...this._def,
+          exactLength: { value: len, message: errorUtil.toString(message) }
+        });
+      }
+      nonempty(message) {
+        return this.min(1, message);
+      }
+    };
+    ZodArray.create = (schema3, params) => {
+      return new ZodArray({
+        type: schema3,
+        minLength: null,
+        maxLength: null,
+        exactLength: null,
+        typeName: ZodFirstPartyTypeKind.ZodArray,
+        ...processCreateParams(params)
+      });
+    };
+    (function(objectUtil2) {
+      objectUtil2.mergeShapes = (first, second) => {
+        return {
+          ...first,
+          ...second
+          // second overwrites first
+        };
+      };
+    })(objectUtil || (objectUtil = {}));
+    AugmentFactory = (def) => (augmentation) => {
+      return new ZodObject({
+        ...def,
+        shape: () => ({
+          ...def.shape(),
+          ...augmentation
+        })
+      });
+    };
+    ZodObject = class _ZodObject extends ZodType {
+      constructor() {
+        super(...arguments);
+        this._cached = null;
+        this.nonstrict = this.passthrough;
+        this.augment = AugmentFactory(this._def);
+        this.extend = AugmentFactory(this._def);
+      }
+      _getCached() {
+        if (this._cached !== null)
+          return this._cached;
+        const shape = this._def.shape();
+        const keys = util.objectKeys(shape);
+        return this._cached = { shape, keys };
+      }
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.object) {
+          const ctx2 = this._getOrReturnCtx(input);
+          addIssueToContext(ctx2, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.object,
+            received: ctx2.parsedType
+          });
+          return INVALID;
+        }
+        const { status, ctx } = this._processInputParams(input);
+        const { shape, keys: shapeKeys } = this._getCached();
+        const extraKeys = [];
+        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
+          for (const key in ctx.data) {
+            if (!shapeKeys.includes(key)) {
+              extraKeys.push(key);
+            }
+          }
+        }
+        const pairs = [];
+        for (const key of shapeKeys) {
+          const keyValidator = shape[key];
+          const value = ctx.data[key];
+          pairs.push({
+            key: { status: "valid", value: key },
+            value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+            alwaysSet: key in ctx.data
+          });
+        }
+        if (this._def.catchall instanceof ZodNever) {
+          const unknownKeys = this._def.unknownKeys;
+          if (unknownKeys === "passthrough") {
+            for (const key of extraKeys) {
+              pairs.push({
+                key: { status: "valid", value: key },
+                value: { status: "valid", value: ctx.data[key] }
+              });
+            }
+          } else if (unknownKeys === "strict") {
+            if (extraKeys.length > 0) {
+              addIssueToContext(ctx, {
+                code: ZodIssueCode.unrecognized_keys,
+                keys: extraKeys
+              });
+              status.dirty();
+            }
+          } else if (unknownKeys === "strip")
+            ;
+          else {
+            throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
+          }
+        } else {
+          const catchall = this._def.catchall;
+          for (const key of extraKeys) {
+            const value = ctx.data[key];
+            pairs.push({
+              key: { status: "valid", value: key },
+              value: catchall._parse(
+                new ParseInputLazyPath(ctx, value, ctx.path, key)
+                //, ctx.child(key), value, getParsedType(value)
+              ),
+              alwaysSet: key in ctx.data
+            });
+          }
+        }
+        if (ctx.common.async) {
+          return Promise.resolve().then(async () => {
+            const syncPairs = [];
+            for (const pair of pairs) {
+              const key = await pair.key;
+              syncPairs.push({
+                key,
+                value: await pair.value,
+                alwaysSet: pair.alwaysSet
+              });
+            }
+            return syncPairs;
+          }).then((syncPairs) => {
+            return ParseStatus.mergeObjectSync(status, syncPairs);
+          });
+        } else {
+          return ParseStatus.mergeObjectSync(status, pairs);
+        }
+      }
+      get shape() {
+        return this._def.shape();
+      }
+      strict(message) {
+        errorUtil.errToObj;
+        return new _ZodObject({
+          ...this._def,
+          unknownKeys: "strict",
+          ...message !== void 0 ? {
+            errorMap: (issue, ctx) => {
+              var _a, _b, _c, _d;
+              const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+              if (issue.code === "unrecognized_keys")
+                return {
+                  message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
+                };
+              return {
+                message: defaultError
+              };
+            }
+          } : {}
+        });
+      }
+      strip() {
+        return new _ZodObject({
+          ...this._def,
+          unknownKeys: "strip"
+        });
+      }
+      passthrough() {
+        return new _ZodObject({
+          ...this._def,
+          unknownKeys: "passthrough"
+        });
+      }
+      setKey(key, schema3) {
+        return this.augment({ [key]: schema3 });
+      }
+      /**
+       * Prior to zod@1.0.12 there was a bug in the
+       * inferred type of merged objects. Please
+       * upgrade if you are experiencing issues.
+       */
+      merge(merging) {
+        const merged = new _ZodObject({
+          unknownKeys: merging._def.unknownKeys,
+          catchall: merging._def.catchall,
+          shape: () => objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+          typeName: ZodFirstPartyTypeKind.ZodObject
+        });
+        return merged;
+      }
+      catchall(index4) {
+        return new _ZodObject({
+          ...this._def,
+          catchall: index4
+        });
+      }
+      pick(mask) {
+        const shape = {};
+        util.objectKeys(mask).map((key) => {
+          if (this.shape[key])
+            shape[key] = this.shape[key];
+        });
+        return new _ZodObject({
+          ...this._def,
+          shape: () => shape
+        });
+      }
+      omit(mask) {
+        const shape = {};
+        util.objectKeys(this.shape).map((key) => {
+          if (util.objectKeys(mask).indexOf(key) === -1) {
+            shape[key] = this.shape[key];
+          }
+        });
+        return new _ZodObject({
+          ...this._def,
+          shape: () => shape
+        });
+      }
+      deepPartial() {
+        return deepPartialify(this);
+      }
+      partial(mask) {
+        const newShape = {};
+        if (mask) {
+          util.objectKeys(this.shape).map((key) => {
+            if (util.objectKeys(mask).indexOf(key) === -1) {
+              newShape[key] = this.shape[key];
+            } else {
+              newShape[key] = this.shape[key].optional();
+            }
+          });
+          return new _ZodObject({
+            ...this._def,
+            shape: () => newShape
+          });
+        } else {
+          for (const key in this.shape) {
+            const fieldSchema = this.shape[key];
+            newShape[key] = fieldSchema.optional();
+          }
+        }
+        return new _ZodObject({
+          ...this._def,
+          shape: () => newShape
+        });
+      }
+      required(mask) {
+        const newShape = {};
+        if (mask) {
+          util.objectKeys(this.shape).map((key) => {
+            if (util.objectKeys(mask).indexOf(key) === -1) {
+              newShape[key] = this.shape[key];
+            } else {
+              const fieldSchema = this.shape[key];
+              let newField = fieldSchema;
+              while (newField instanceof ZodOptional) {
+                newField = newField._def.innerType;
+              }
+              newShape[key] = newField;
+            }
+          });
+        } else {
+          for (const key in this.shape) {
+            const fieldSchema = this.shape[key];
+            let newField = fieldSchema;
+            while (newField instanceof ZodOptional) {
+              newField = newField._def.innerType;
+            }
+            newShape[key] = newField;
+          }
+        }
+        return new _ZodObject({
+          ...this._def,
+          shape: () => newShape
+        });
+      }
+      keyof() {
+        return createZodEnum(util.objectKeys(this.shape));
+      }
+    };
+    ZodObject.create = (shape, params) => {
+      return new ZodObject({
+        shape: () => shape,
+        unknownKeys: "strip",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params)
+      });
+    };
+    ZodObject.strictCreate = (shape, params) => {
+      return new ZodObject({
+        shape: () => shape,
+        unknownKeys: "strict",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params)
+      });
+    };
+    ZodObject.lazycreate = (shape, params) => {
+      return new ZodObject({
+        shape,
+        unknownKeys: "strip",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params)
+      });
+    };
+    ZodUnion = class extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const options = this._def.options;
+        function handleResults(results) {
+          for (const result of results) {
+            if (result.result.status === "valid") {
+              return result.result;
+            }
+          }
+          for (const result of results) {
+            if (result.result.status === "dirty") {
+              ctx.common.issues.push(...result.ctx.common.issues);
+              return result.result;
+            }
+          }
+          const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_union,
+            unionErrors
+          });
+          return INVALID;
+        }
+        if (ctx.common.async) {
+          return Promise.all(options.map(async (option) => {
+            const childCtx = {
+              ...ctx,
+              common: {
+                ...ctx.common,
+                issues: []
+              },
+              parent: null
+            };
+            return {
+              result: await option._parseAsync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: childCtx
+              }),
+              ctx: childCtx
+            };
+          })).then(handleResults);
+        } else {
+          let dirty = void 0;
+          const issues = [];
+          for (const option of options) {
+            const childCtx = {
+              ...ctx,
+              common: {
+                ...ctx.common,
+                issues: []
+              },
+              parent: null
+            };
+            const result = option._parseSync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: childCtx
+            });
+            if (result.status === "valid") {
+              return result;
+            } else if (result.status === "dirty" && !dirty) {
+              dirty = { result, ctx: childCtx };
+            }
+            if (childCtx.common.issues.length) {
+              issues.push(childCtx.common.issues);
+            }
+          }
+          if (dirty) {
+            ctx.common.issues.push(...dirty.ctx.common.issues);
+            return dirty.result;
+          }
+          const unionErrors = issues.map((issues2) => new ZodError(issues2));
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_union,
+            unionErrors
+          });
+          return INVALID;
+        }
+      }
+      get options() {
+        return this._def.options;
+      }
+    };
+    ZodUnion.create = (types, params) => {
+      return new ZodUnion({
+        options: types,
+        typeName: ZodFirstPartyTypeKind.ZodUnion,
+        ...processCreateParams(params)
+      });
+    };
+    getDiscriminator = (type) => {
+      if (type instanceof ZodLazy) {
+        return getDiscriminator(type.schema);
+      } else if (type instanceof ZodEffects) {
+        return getDiscriminator(type.innerType());
+      } else if (type instanceof ZodLiteral) {
+        return [type.value];
+      } else if (type instanceof ZodEnum) {
+        return type.options;
+      } else if (type instanceof ZodNativeEnum) {
+        return Object.keys(type.enum);
+      } else if (type instanceof ZodDefault) {
+        return getDiscriminator(type._def.innerType);
+      } else if (type instanceof ZodUndefined) {
+        return [void 0];
+      } else if (type instanceof ZodNull) {
+        return [null];
+      } else {
+        return null;
+      }
+    };
+    ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.object) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.object,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        const discriminator = this.discriminator;
+        const discriminatorValue = ctx.data[discriminator];
+        const option = this.optionsMap.get(discriminatorValue);
+        if (!option) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_union_discriminator,
+            options: Array.from(this.optionsMap.keys()),
+            path: [discriminator]
+          });
+          return INVALID;
+        }
+        if (ctx.common.async) {
+          return option._parseAsync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+        } else {
+          return option._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      }
+      get discriminator() {
+        return this._def.discriminator;
+      }
+      get options() {
+        return this._def.options;
+      }
+      get optionsMap() {
+        return this._def.optionsMap;
+      }
+      /**
+       * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+       * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+       * have a different value for each object in the union.
+       * @param discriminator the name of the discriminator property
+       * @param types an array of object schemas
+       * @param params
+       */
+      static create(discriminator, options, params) {
+        const optionsMap = /* @__PURE__ */ new Map();
+        for (const type of options) {
+          const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+          if (!discriminatorValues) {
+            throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
+          }
+          for (const value of discriminatorValues) {
+            if (optionsMap.has(value)) {
+              throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
+            }
+            optionsMap.set(value, type);
+          }
+        }
+        return new _ZodDiscriminatedUnion({
+          typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+          discriminator,
+          options,
+          optionsMap,
+          ...processCreateParams(params)
+        });
+      }
+    };
+    ZodIntersection = class extends ZodType {
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        const handleParsed = (parsedLeft, parsedRight) => {
+          if (isAborted(parsedLeft) || isAborted(parsedRight)) {
+            return INVALID;
+          }
+          const merged = mergeValues(parsedLeft.value, parsedRight.value);
+          if (!merged.valid) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.invalid_intersection_types
+            });
+            return INVALID;
+          }
+          if (isDirty(parsedLeft) || isDirty(parsedRight)) {
+            status.dirty();
+          }
+          return { status: status.value, value: merged.data };
+        };
+        if (ctx.common.async) {
+          return Promise.all([
+            this._def.left._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            }),
+            this._def.right._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            })
+          ]).then(([left, right]) => handleParsed(left, right));
+        } else {
+          return handleParsed(this._def.left._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          }), this._def.right._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          }));
+        }
+      }
+    };
+    ZodIntersection.create = (left, right, params) => {
+      return new ZodIntersection({
+        left,
+        right,
+        typeName: ZodFirstPartyTypeKind.ZodIntersection,
+        ...processCreateParams(params)
+      });
+    };
+    ZodTuple = class _ZodTuple extends ZodType {
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.array) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.array,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        if (ctx.data.length < this._def.items.length) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_small,
+            minimum: this._def.items.length,
+            inclusive: true,
+            exact: false,
+            type: "array"
+          });
+          return INVALID;
+        }
+        const rest = this._def.rest;
+        if (!rest && ctx.data.length > this._def.items.length) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_big,
+            maximum: this._def.items.length,
+            inclusive: true,
+            exact: false,
+            type: "array"
+          });
+          status.dirty();
+        }
+        const items = ctx.data.map((item, itemIndex) => {
+          const schema3 = this._def.items[itemIndex] || this._def.rest;
+          if (!schema3)
+            return null;
+          return schema3._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+        }).filter((x) => !!x);
+        if (ctx.common.async) {
+          return Promise.all(items).then((results) => {
+            return ParseStatus.mergeArray(status, results);
+          });
+        } else {
+          return ParseStatus.mergeArray(status, items);
+        }
+      }
+      get items() {
+        return this._def.items;
+      }
+      rest(rest) {
+        return new _ZodTuple({
+          ...this._def,
+          rest
+        });
+      }
+    };
+    ZodTuple.create = (schemas, params) => {
+      if (!Array.isArray(schemas)) {
+        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+      }
+      return new ZodTuple({
+        items: schemas,
+        typeName: ZodFirstPartyTypeKind.ZodTuple,
+        rest: null,
+        ...processCreateParams(params)
+      });
+    };
+    ZodRecord = class _ZodRecord extends ZodType {
+      get keySchema() {
+        return this._def.keyType;
+      }
+      get valueSchema() {
+        return this._def.valueType;
+      }
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.object) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.object,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        const pairs = [];
+        const keyType = this._def.keyType;
+        const valueType = this._def.valueType;
+        for (const key in ctx.data) {
+          pairs.push({
+            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+            value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key))
+          });
+        }
+        if (ctx.common.async) {
+          return ParseStatus.mergeObjectAsync(status, pairs);
+        } else {
+          return ParseStatus.mergeObjectSync(status, pairs);
+        }
+      }
+      get element() {
+        return this._def.valueType;
+      }
+      static create(first, second, third) {
+        if (second instanceof ZodType) {
+          return new _ZodRecord({
+            keyType: first,
+            valueType: second,
+            typeName: ZodFirstPartyTypeKind.ZodRecord,
+            ...processCreateParams(third)
+          });
+        }
+        return new _ZodRecord({
+          keyType: ZodString.create(),
+          valueType: first,
+          typeName: ZodFirstPartyTypeKind.ZodRecord,
+          ...processCreateParams(second)
+        });
+      }
+    };
+    ZodMap = class extends ZodType {
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.map) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.map,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        const keyType = this._def.keyType;
+        const valueType = this._def.valueType;
+        const pairs = [...ctx.data.entries()].map(([key, value], index4) => {
+          return {
+            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index4, "key"])),
+            value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index4, "value"]))
+          };
+        });
+        if (ctx.common.async) {
+          const finalMap = /* @__PURE__ */ new Map();
+          return Promise.resolve().then(async () => {
+            for (const pair of pairs) {
+              const key = await pair.key;
+              const value = await pair.value;
+              if (key.status === "aborted" || value.status === "aborted") {
+                return INVALID;
+              }
+              if (key.status === "dirty" || value.status === "dirty") {
+                status.dirty();
+              }
+              finalMap.set(key.value, value.value);
+            }
+            return { status: status.value, value: finalMap };
+          });
+        } else {
+          const finalMap = /* @__PURE__ */ new Map();
+          for (const pair of pairs) {
+            const key = pair.key;
+            const value = pair.value;
+            if (key.status === "aborted" || value.status === "aborted") {
+              return INVALID;
+            }
+            if (key.status === "dirty" || value.status === "dirty") {
+              status.dirty();
+            }
+            finalMap.set(key.value, value.value);
+          }
+          return { status: status.value, value: finalMap };
+        }
+      }
+    };
+    ZodMap.create = (keyType, valueType, params) => {
+      return new ZodMap({
+        valueType,
+        keyType,
+        typeName: ZodFirstPartyTypeKind.ZodMap,
+        ...processCreateParams(params)
+      });
+    };
+    ZodSet = class _ZodSet extends ZodType {
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.set) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.set,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        const def = this._def;
+        if (def.minSize !== null) {
+          if (ctx.data.size < def.minSize.value) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_small,
+              minimum: def.minSize.value,
+              type: "set",
+              inclusive: true,
+              exact: false,
+              message: def.minSize.message
+            });
+            status.dirty();
+          }
+        }
+        if (def.maxSize !== null) {
+          if (ctx.data.size > def.maxSize.value) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_big,
+              maximum: def.maxSize.value,
+              type: "set",
+              inclusive: true,
+              exact: false,
+              message: def.maxSize.message
+            });
+            status.dirty();
+          }
+        }
+        const valueType = this._def.valueType;
+        function finalizeSet(elements2) {
+          const parsedSet = /* @__PURE__ */ new Set();
+          for (const element of elements2) {
+            if (element.status === "aborted")
+              return INVALID;
+            if (element.status === "dirty")
+              status.dirty();
+            parsedSet.add(element.value);
+          }
+          return { status: status.value, value: parsedSet };
+        }
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+        if (ctx.common.async) {
+          return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+        } else {
+          return finalizeSet(elements);
+        }
+      }
+      min(minSize, message) {
+        return new _ZodSet({
+          ...this._def,
+          minSize: { value: minSize, message: errorUtil.toString(message) }
+        });
+      }
+      max(maxSize, message) {
+        return new _ZodSet({
+          ...this._def,
+          maxSize: { value: maxSize, message: errorUtil.toString(message) }
+        });
+      }
+      size(size, message) {
+        return this.min(size, message).max(size, message);
+      }
+      nonempty(message) {
+        return this.min(1, message);
+      }
+    };
+    ZodSet.create = (valueType, params) => {
+      return new ZodSet({
+        valueType,
+        minSize: null,
+        maxSize: null,
+        typeName: ZodFirstPartyTypeKind.ZodSet,
+        ...processCreateParams(params)
+      });
+    };
+    ZodFunction = class _ZodFunction extends ZodType {
+      constructor() {
+        super(...arguments);
+        this.validate = this.implement;
+      }
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.function) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.function,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        function makeArgsIssue(args, error2) {
+          return makeIssue({
+            data: args,
+            path: ctx.path,
+            errorMaps: [
+              ctx.common.contextualErrorMap,
+              ctx.schemaErrorMap,
+              getErrorMap(),
+              errorMap
+            ].filter((x) => !!x),
+            issueData: {
+              code: ZodIssueCode.invalid_arguments,
+              argumentsError: error2
+            }
+          });
+        }
+        function makeReturnsIssue(returns, error2) {
+          return makeIssue({
+            data: returns,
+            path: ctx.path,
+            errorMaps: [
+              ctx.common.contextualErrorMap,
+              ctx.schemaErrorMap,
+              getErrorMap(),
+              errorMap
+            ].filter((x) => !!x),
+            issueData: {
+              code: ZodIssueCode.invalid_return_type,
+              returnTypeError: error2
+            }
+          });
+        }
+        const params = { errorMap: ctx.common.contextualErrorMap };
+        const fn = ctx.data;
+        if (this._def.returns instanceof ZodPromise) {
+          return OK(async (...args) => {
+            const error2 = new ZodError([]);
+            const parsedArgs = await this._def.args.parseAsync(args, params).catch((e) => {
+              error2.addIssue(makeArgsIssue(args, e));
+              throw error2;
+            });
+            const result = await fn(...parsedArgs);
+            const parsedReturns = await this._def.returns._def.type.parseAsync(result, params).catch((e) => {
+              error2.addIssue(makeReturnsIssue(result, e));
+              throw error2;
+            });
+            return parsedReturns;
+          });
+        } else {
+          return OK((...args) => {
+            const parsedArgs = this._def.args.safeParse(args, params);
+            if (!parsedArgs.success) {
+              throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+            }
+            const result = fn(...parsedArgs.data);
+            const parsedReturns = this._def.returns.safeParse(result, params);
+            if (!parsedReturns.success) {
+              throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+            }
+            return parsedReturns.data;
+          });
+        }
+      }
+      parameters() {
+        return this._def.args;
+      }
+      returnType() {
+        return this._def.returns;
+      }
+      args(...items) {
+        return new _ZodFunction({
+          ...this._def,
+          args: ZodTuple.create(items).rest(ZodUnknown.create())
+        });
+      }
+      returns(returnType) {
+        return new _ZodFunction({
+          ...this._def,
+          returns: returnType
+        });
+      }
+      implement(func) {
+        const validatedFunc = this.parse(func);
+        return validatedFunc;
+      }
+      strictImplement(func) {
+        const validatedFunc = this.parse(func);
+        return validatedFunc;
+      }
+      static create(args, returns, params) {
+        return new _ZodFunction({
+          args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
+          returns: returns || ZodUnknown.create(),
+          typeName: ZodFirstPartyTypeKind.ZodFunction,
+          ...processCreateParams(params)
+        });
+      }
+    };
+    ZodLazy = class extends ZodType {
+      get schema() {
+        return this._def.getter();
+      }
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const lazySchema = this._def.getter();
+        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+      }
+    };
+    ZodLazy.create = (getter, params) => {
+      return new ZodLazy({
+        getter,
+        typeName: ZodFirstPartyTypeKind.ZodLazy,
+        ...processCreateParams(params)
+      });
+    };
+    ZodLiteral = class extends ZodType {
+      _parse(input) {
+        if (input.data !== this._def.value) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_literal,
+            expected: this._def.value
+          });
+          return INVALID;
+        }
+        return { status: "valid", value: input.data };
+      }
+      get value() {
+        return this._def.value;
+      }
+    };
+    ZodLiteral.create = (value, params) => {
+      return new ZodLiteral({
+        value,
+        typeName: ZodFirstPartyTypeKind.ZodLiteral,
+        ...processCreateParams(params)
+      });
+    };
+    ZodEnum = class extends ZodType {
+      _parse(input) {
+        if (typeof input.data !== "string") {
+          const ctx = this._getOrReturnCtx(input);
+          const expectedValues = this._def.values;
+          addIssueToContext(ctx, {
+            expected: util.joinValues(expectedValues),
+            received: ctx.parsedType,
+            code: ZodIssueCode.invalid_type
+          });
+          return INVALID;
+        }
+        if (this._def.values.indexOf(input.data) === -1) {
+          const ctx = this._getOrReturnCtx(input);
+          const expectedValues = this._def.values;
+          addIssueToContext(ctx, {
+            received: ctx.data,
+            code: ZodIssueCode.invalid_enum_value,
+            options: expectedValues
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+      get options() {
+        return this._def.values;
+      }
+      get enum() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+          enumValues[val] = val;
+        }
+        return enumValues;
+      }
+      get Values() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+          enumValues[val] = val;
+        }
+        return enumValues;
+      }
+      get Enum() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+          enumValues[val] = val;
+        }
+        return enumValues;
+      }
+    };
+    ZodEnum.create = createZodEnum;
+    ZodNativeEnum = class extends ZodType {
+      _parse(input) {
+        const nativeEnumValues = util.getValidEnumValues(this._def.values);
+        const ctx = this._getOrReturnCtx(input);
+        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
+          const expectedValues = util.objectValues(nativeEnumValues);
+          addIssueToContext(ctx, {
+            expected: util.joinValues(expectedValues),
+            received: ctx.parsedType,
+            code: ZodIssueCode.invalid_type
+          });
+          return INVALID;
+        }
+        if (nativeEnumValues.indexOf(input.data) === -1) {
+          const expectedValues = util.objectValues(nativeEnumValues);
+          addIssueToContext(ctx, {
+            received: ctx.data,
+            code: ZodIssueCode.invalid_enum_value,
+            options: expectedValues
+          });
+          return INVALID;
+        }
+        return OK(input.data);
+      }
+      get enum() {
+        return this._def.values;
+      }
+    };
+    ZodNativeEnum.create = (values, params) => {
+      return new ZodNativeEnum({
+        values,
+        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+        ...processCreateParams(params)
+      });
+    };
+    ZodPromise = class extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.promise,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+        return OK(promisified.then((data) => {
+          return this._def.type.parseAsync(data, {
+            path: ctx.path,
+            errorMap: ctx.common.contextualErrorMap
+          });
+        }));
+      }
+    };
+    ZodPromise.create = (schema3, params) => {
+      return new ZodPromise({
+        type: schema3,
+        typeName: ZodFirstPartyTypeKind.ZodPromise,
+        ...processCreateParams(params)
+      });
+    };
+    ZodEffects = class extends ZodType {
+      innerType() {
+        return this._def.schema;
+      }
+      sourceType() {
+        return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+      }
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        const effect = this._def.effect || null;
+        if (effect.type === "preprocess") {
+          const processed = effect.transform(ctx.data);
+          if (ctx.common.async) {
+            return Promise.resolve(processed).then((processed2) => {
+              return this._def.schema._parseAsync({
+                data: processed2,
+                path: ctx.path,
+                parent: ctx
+              });
+            });
+          } else {
+            return this._def.schema._parseSync({
+              data: processed,
+              path: ctx.path,
+              parent: ctx
+            });
+          }
+        }
+        const checkCtx = {
+          addIssue: (arg) => {
+            addIssueToContext(ctx, arg);
+            if (arg.fatal) {
+              status.abort();
+            } else {
+              status.dirty();
+            }
+          },
+          get path() {
+            return ctx.path;
+          }
+        };
+        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+        if (effect.type === "refinement") {
+          const executeRefinement = (acc) => {
+            const result = effect.refinement(acc, checkCtx);
+            if (ctx.common.async) {
+              return Promise.resolve(result);
+            }
+            if (result instanceof Promise) {
+              throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+            }
+            return acc;
+          };
+          if (ctx.common.async === false) {
+            const inner = this._def.schema._parseSync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            });
+            if (inner.status === "aborted")
+              return INVALID;
+            if (inner.status === "dirty")
+              status.dirty();
+            executeRefinement(inner.value);
+            return { status: status.value, value: inner.value };
+          } else {
+            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+              if (inner.status === "aborted")
+                return INVALID;
+              if (inner.status === "dirty")
+                status.dirty();
+              return executeRefinement(inner.value).then(() => {
+                return { status: status.value, value: inner.value };
+              });
+            });
+          }
+        }
+        if (effect.type === "transform") {
+          if (ctx.common.async === false) {
+            const base = this._def.schema._parseSync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            });
+            if (!isValid(base))
+              return base;
+            const result = effect.transform(base.value, checkCtx);
+            if (result instanceof Promise) {
+              throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+            }
+            return { status: status.value, value: result };
+          } else {
+            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+              if (!isValid(base))
+                return base;
+              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+            });
+          }
+        }
+        util.assertNever(effect);
+      }
+    };
+    ZodEffects.create = (schema3, effect, params) => {
+      return new ZodEffects({
+        schema: schema3,
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        effect,
+        ...processCreateParams(params)
+      });
+    };
+    ZodEffects.createWithPreprocess = (preprocess, schema3, params) => {
+      return new ZodEffects({
+        schema: schema3,
+        effect: { type: "preprocess", transform: preprocess },
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        ...processCreateParams(params)
+      });
+    };
+    ZodOptional = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType === ZodParsedType.undefined) {
+          return OK(void 0);
+        }
+        return this._def.innerType._parse(input);
+      }
+      unwrap() {
+        return this._def.innerType;
+      }
+    };
+    ZodOptional.create = (type, params) => {
+      return new ZodOptional({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodOptional,
+        ...processCreateParams(params)
+      });
+    };
+    ZodNullable = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType === ZodParsedType.null) {
+          return OK(null);
+        }
+        return this._def.innerType._parse(input);
+      }
+      unwrap() {
+        return this._def.innerType;
+      }
+    };
+    ZodNullable.create = (type, params) => {
+      return new ZodNullable({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodNullable,
+        ...processCreateParams(params)
+      });
+    };
+    ZodDefault = class extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        let data = ctx.data;
+        if (ctx.parsedType === ZodParsedType.undefined) {
+          data = this._def.defaultValue();
+        }
+        return this._def.innerType._parse({
+          data,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+      removeDefault() {
+        return this._def.innerType;
+      }
+    };
+    ZodDefault.create = (type, params) => {
+      return new ZodDefault({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodDefault,
+        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+        ...processCreateParams(params)
+      });
+    };
+    ZodCatch = class extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const result = this._def.innerType._parse({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (isAsync(result)) {
+          return result.then((result2) => {
+            return {
+              status: "valid",
+              value: result2.status === "valid" ? result2.value : this._def.defaultValue()
+            };
+          });
+        } else {
+          return {
+            status: "valid",
+            value: result.status === "valid" ? result.value : this._def.defaultValue()
+          };
+        }
+      }
+      removeDefault() {
+        return this._def.innerType;
+      }
+    };
+    ZodCatch.create = (type, params) => {
+      return new ZodCatch({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodCatch,
+        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+        ...processCreateParams(params)
+      });
+    };
+    ZodNaN = class extends ZodType {
+      _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.nan) {
+          const ctx = this._getOrReturnCtx(input);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: ZodParsedType.nan,
+            received: ctx.parsedType
+          });
+          return INVALID;
+        }
+        return { status: "valid", value: input.data };
+      }
+    };
+    ZodNaN.create = (params) => {
+      return new ZodNaN({
+        typeName: ZodFirstPartyTypeKind.ZodNaN,
+        ...processCreateParams(params)
+      });
+    };
+    BRAND = Symbol("zod_brand");
+    ZodBranded = class extends ZodType {
+      _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const data = ctx.data;
+        return this._def.type._parse({
+          data,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+      unwrap() {
+        return this._def.type;
+      }
+    };
+    ZodPipeline = class _ZodPipeline extends ZodType {
+      _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        if (ctx.common.async) {
+          const handleAsync = async () => {
+            const inResult = await this._def.in._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            });
+            if (inResult.status === "aborted")
+              return INVALID;
+            if (inResult.status === "dirty") {
+              status.dirty();
+              return DIRTY(inResult.value);
+            } else {
+              return this._def.out._parseAsync({
+                data: inResult.value,
+                path: ctx.path,
+                parent: ctx
+              });
+            }
+          };
+          return handleAsync();
+        } else {
+          const inResult = this._def.in._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (inResult.status === "aborted")
+            return INVALID;
+          if (inResult.status === "dirty") {
+            status.dirty();
+            return {
+              status: "dirty",
+              value: inResult.value
+            };
+          } else {
+            return this._def.out._parseSync({
+              data: inResult.value,
+              path: ctx.path,
+              parent: ctx
+            });
+          }
+        }
+      }
+      static create(a, b) {
+        return new _ZodPipeline({
+          in: a,
+          out: b,
+          typeName: ZodFirstPartyTypeKind.ZodPipeline
+        });
+      }
+    };
+    late = {
+      object: ZodObject.lazycreate
+    };
+    (function(ZodFirstPartyTypeKind2) {
+      ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+      ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+      ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+      ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+      ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+      ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+      ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+      ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+      ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+      ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+      ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+      ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+      ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+      ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+      ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+      ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+      ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+      ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+      ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+      ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+      ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+      ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+      ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+      ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+      ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+      ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+      ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+      ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+      ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+      ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+      ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+      ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+      ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+      ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+      ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+    })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+    stringType = ZodString.create;
+    numberType = ZodNumber.create;
+    nanType = ZodNaN.create;
+    bigIntType = ZodBigInt.create;
+    booleanType = ZodBoolean.create;
+    dateType = ZodDate.create;
+    symbolType = ZodSymbol.create;
+    undefinedType = ZodUndefined.create;
+    nullType = ZodNull.create;
+    anyType = ZodAny.create;
+    unknownType = ZodUnknown.create;
+    neverType = ZodNever.create;
+    voidType = ZodVoid.create;
+    arrayType = ZodArray.create;
+    objectType = ZodObject.create;
+    strictObjectType = ZodObject.strictCreate;
+    unionType = ZodUnion.create;
+    discriminatedUnionType = ZodDiscriminatedUnion.create;
+    intersectionType = ZodIntersection.create;
+    tupleType = ZodTuple.create;
+    recordType = ZodRecord.create;
+    mapType = ZodMap.create;
+    setType = ZodSet.create;
+    functionType = ZodFunction.create;
+    lazyType = ZodLazy.create;
+    literalType = ZodLiteral.create;
+    enumType = ZodEnum.create;
+    nativeEnumType = ZodNativeEnum.create;
+    promiseType = ZodPromise.create;
+    effectsType = ZodEffects.create;
+    optionalType = ZodOptional.create;
+    nullableType = ZodNullable.create;
+    preprocessType = ZodEffects.createWithPreprocess;
+    pipelineType = ZodPipeline.create;
+  }
+});
+
+// src/serializer/mysqlSchema.ts
+var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, kitInternals, dialect, schemaHash, schemaInternalV3, schemaInternalV4, schemaInternalV5, schemaInternal, schemaV3, schemaV4, schemaV5, schema, tableSquashedV4, tableSquashed, schemaSquashed, schemaSquashedV4, mysqlSchema, mysqlSchemaV5, backwardCompatibleMysqlSchema, dryMySql;
+var init_mysqlSchema = __esm({
+  "src/serializer/mysqlSchema.ts"() {
+    "use strict";
+    init_global();
+    init_lib();
+    index = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      isUnique: booleanType(),
+      using: enumType(["btree", "hash"]).optional(),
+      algorithm: enumType(["default", "inplace", "copy"]).optional(),
+      lock: enumType(["default", "none", "shared", "exclusive"]).optional()
+    }).strict();
+    fk = objectType({
+      name: stringType(),
+      tableFrom: stringType(),
+      columnsFrom: stringType().array(),
+      tableTo: stringType(),
+      columnsTo: stringType().array(),
+      onUpdate: stringType().optional(),
+      onDelete: stringType().optional()
+    }).strict();
+    column = objectType({
+      name: stringType(),
+      type: stringType(),
+      primaryKey: booleanType(),
+      notNull: booleanType(),
+      autoincrement: booleanType().optional(),
+      default: anyType().optional(),
+      onUpdate: anyType().optional()
+    }).strict();
+    tableV3 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column),
+      indexes: recordType(stringType(), index),
+      foreignKeys: recordType(stringType(), fk)
+    }).strict();
+    compositePK = objectType({
+      name: stringType(),
+      columns: stringType().array()
+    }).strict();
+    uniqueConstraint = objectType({
+      name: stringType(),
+      columns: stringType().array()
+    }).strict();
+    tableV4 = objectType({
+      name: stringType(),
+      schema: stringType().optional(),
+      columns: recordType(stringType(), column),
+      indexes: recordType(stringType(), index),
+      foreignKeys: recordType(stringType(), fk)
+    }).strict();
+    table = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column),
+      indexes: recordType(stringType(), index),
+      foreignKeys: recordType(stringType(), fk),
+      compositePrimaryKeys: recordType(stringType(), compositePK),
+      uniqueConstraints: recordType(stringType(), uniqueConstraint).default({})
+    }).strict();
+    kitInternals = objectType({
+      tables: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
+          )
+        }).optional()
+      )
+    }).optional();
+    dialect = literalType("mysql");
+    schemaHash = objectType({
+      id: stringType(),
+      prevId: stringType()
+    });
+    schemaInternalV3 = objectType({
+      version: literalType("3"),
+      dialect,
+      tables: recordType(stringType(), tableV3)
+    }).strict();
+    schemaInternalV4 = objectType({
+      version: literalType("4"),
+      dialect,
+      tables: recordType(stringType(), tableV4),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    schemaInternalV5 = objectType({
+      version: literalType("5"),
+      dialect,
+      tables: recordType(stringType(), table),
+      schemas: recordType(stringType(), stringType()),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      }),
+      internal: kitInternals
+    }).strict();
+    schemaInternal = objectType({
+      version: literalType("5"),
+      dialect,
+      tables: recordType(stringType(), table),
+      _meta: objectType({
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      }),
+      internal: kitInternals
+    }).strict();
+    schemaV3 = schemaInternalV3.merge(schemaHash);
+    schemaV4 = schemaInternalV4.merge(schemaHash);
+    schemaV5 = schemaInternalV5.merge(schemaHash);
+    schema = schemaInternal.merge(schemaHash);
+    tableSquashedV4 = objectType({
+      name: stringType(),
+      schema: stringType().optional(),
+      columns: recordType(stringType(), column),
+      indexes: recordType(stringType(), stringType()),
+      foreignKeys: recordType(stringType(), stringType())
+    }).strict();
+    tableSquashed = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column),
+      indexes: recordType(stringType(), stringType()),
+      foreignKeys: recordType(stringType(), stringType()),
+      compositePrimaryKeys: recordType(stringType(), stringType()),
+      uniqueConstraints: recordType(stringType(), stringType()).default({})
+    }).strict();
+    schemaSquashed = objectType({
+      version: literalType("5"),
+      dialect,
+      tables: recordType(stringType(), tableSquashed)
+    }).strict();
+    schemaSquashedV4 = objectType({
+      version: literalType("4"),
+      dialect,
+      tables: recordType(stringType(), tableSquashedV4),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    mysqlSchema = schema;
+    mysqlSchemaV5 = schemaV5;
+    backwardCompatibleMysqlSchema = unionType([mysqlSchemaV5, schema]);
+    dryMySql = mysqlSchema.parse({
+      version: "5",
+      dialect: "mysql",
+      id: originUUID,
+      prevId: "",
+      tables: {},
+      schemas: {},
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
+    });
+  }
+});
+
+// src/serializer/pgSchema.ts
+var indexV2, columnV2, tableV2, enumSchemaV1, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, table2, schemaHash2, kitInternals2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchema2, backwardCompatiblePgSchema, dryPg;
+var init_pgSchema = __esm({
+  "src/serializer/pgSchema.ts"() {
+    "use strict";
+    init_global();
+    init_lib();
+    indexV2 = objectType({
+      name: stringType(),
+      columns: recordType(
+        stringType(),
+        objectType({
+          name: stringType()
+        })
+      ),
+      isUnique: booleanType()
+    }).strict();
+    columnV2 = objectType({
+      name: stringType(),
+      type: stringType(),
+      primaryKey: booleanType(),
+      notNull: booleanType(),
+      default: anyType().optional(),
+      references: stringType().optional()
+    }).strict();
+    tableV2 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), columnV2),
+      indexes: recordType(stringType(), indexV2)
+    }).strict();
+    enumSchemaV1 = objectType({
+      name: stringType(),
+      values: recordType(stringType(), stringType())
+    }).strict();
+    enumSchema = objectType({
+      name: stringType(),
+      schema: stringType(),
+      values: stringType().array()
+    }).strict();
+    pgSchemaV2 = objectType({
+      version: literalType("2"),
+      tables: recordType(stringType(), tableV2),
+      enums: recordType(stringType(), enumSchemaV1)
+    }).strict();
+    references = objectType({
+      foreignKeyName: stringType(),
+      table: stringType(),
+      column: stringType(),
+      onDelete: stringType().optional(),
+      onUpdate: stringType().optional()
+    }).strict();
+    columnV1 = objectType({
+      name: stringType(),
+      type: stringType(),
+      primaryKey: booleanType(),
+      notNull: booleanType(),
+      default: anyType().optional(),
+      references: references.optional()
+    }).strict();
+    tableV1 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), columnV1),
+      indexes: recordType(stringType(), indexV2)
+    }).strict();
+    pgSchemaV1 = objectType({
+      version: literalType("1"),
+      tables: recordType(stringType(), tableV1),
+      enums: recordType(stringType(), enumSchemaV1)
+    }).strict();
+    index2 = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      isUnique: booleanType()
+    }).strict();
+    fk2 = objectType({
+      name: stringType(),
+      tableFrom: stringType(),
+      columnsFrom: stringType().array(),
+      tableTo: stringType(),
+      schemaTo: stringType().optional(),
+      columnsTo: stringType().array(),
+      onUpdate: stringType().optional(),
+      onDelete: stringType().optional()
+    }).strict();
+    column2 = objectType({
+      name: stringType(),
+      type: stringType(),
+      typeSchema: stringType().optional(),
+      primaryKey: booleanType(),
+      notNull: booleanType(),
+      default: anyType().optional(),
+      isUnique: anyType().optional(),
+      uniqueName: stringType().optional(),
+      nullsNotDistinct: booleanType().optional()
+    }).strict();
+    tableV32 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), index2),
+      foreignKeys: recordType(stringType(), fk2)
+    }).strict();
+    compositePK2 = objectType({
+      name: stringType(),
+      columns: stringType().array()
+    }).strict();
+    uniqueConstraint2 = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      nullsNotDistinct: booleanType()
+    }).strict();
+    tableV42 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), index2),
+      foreignKeys: recordType(stringType(), fk2)
+    }).strict();
+    table2 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), index2),
+      foreignKeys: recordType(stringType(), fk2),
+      compositePrimaryKeys: recordType(stringType(), compositePK2),
+      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+    }).strict();
+    schemaHash2 = objectType({
+      id: stringType(),
+      prevId: stringType()
+    });
+    kitInternals2 = objectType({
+      tables: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({
+              isArray: booleanType().optional(),
+              dimensions: numberType().optional(),
+              rawType: stringType().optional()
+            }).optional()
+          )
+        }).optional()
+      )
+    }).optional();
+    pgSchemaInternalV3 = objectType({
+      version: literalType("3"),
+      dialect: literalType("pg"),
+      tables: recordType(stringType(), tableV32),
+      enums: recordType(stringType(), enumSchemaV1)
+    }).strict();
+    pgSchemaInternalV4 = objectType({
+      version: literalType("4"),
+      dialect: literalType("pg"),
+      tables: recordType(stringType(), tableV42),
+      enums: recordType(stringType(), enumSchemaV1),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    pgSchemaInternalV5 = objectType({
+      version: literalType("5"),
+      dialect: literalType("pg"),
+      tables: recordType(stringType(), table2),
+      enums: recordType(stringType(), enumSchemaV1),
+      schemas: recordType(stringType(), stringType()),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      }),
+      internal: kitInternals2
+    }).strict();
+    pgSchemaExternal = objectType({
+      version: literalType("5"),
+      dialect: literalType("pg"),
+      tables: arrayType(table2),
+      enums: arrayType(enumSchemaV1),
+      schemas: arrayType(objectType({ name: stringType() })),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      })
+    }).strict();
+    pgSchemaInternal = objectType({
+      version: literalType("6"),
+      dialect: literalType("pg"),
+      tables: recordType(stringType(), table2),
+      enums: recordType(stringType(), enumSchema),
+      schemas: recordType(stringType(), stringType()),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      }),
+      internal: kitInternals2
+    }).strict();
+    tableSquashed2 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), stringType()),
+      foreignKeys: recordType(stringType(), stringType()),
+      compositePrimaryKeys: recordType(stringType(), stringType()),
+      uniqueConstraints: recordType(stringType(), stringType())
+    }).strict();
+    tableSquashedV42 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), stringType()),
+      foreignKeys: recordType(stringType(), stringType())
+    }).strict();
+    pgSchemaSquashedV4 = objectType({
+      version: literalType("4"),
+      dialect: enumType(["pg"]),
+      tables: recordType(stringType(), tableSquashedV42),
+      enums: recordType(stringType(), enumSchemaV1),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    pgSchemaSquashed = objectType({
+      version: literalType("6"),
+      dialect: enumType(["pg"]),
+      tables: recordType(stringType(), tableSquashed2),
+      enums: recordType(stringType(), enumSchema),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
+    pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
+    pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash2);
+    pgSchema2 = pgSchemaInternal.merge(schemaHash2);
+    backwardCompatiblePgSchema = unionType([pgSchemaV5, pgSchema2]);
+    dryPg = pgSchema2.parse({
+      version: snapshotVersion,
+      dialect: "pg",
+      id: originUUID,
+      prevId: "",
+      tables: {},
+      enums: {},
+      schemas: {},
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
+    });
+  }
+});
+
+// src/serializer/sqliteSchema.ts
+var index3, fk3, compositePK3, column3, tableV33, uniqueConstraint3, table3, dialect2, schemaHash3, schemaInternalV32, schemaInternalV42, latestVersion, schemaInternal2, schemaV32, schemaV42, schema2, tableSquashed3, schemaSquashed2, drySQLite;
+var init_sqliteSchema = __esm({
+  "src/serializer/sqliteSchema.ts"() {
+    "use strict";
+    init_global();
+    init_lib();
+    index3 = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      where: stringType().optional(),
+      isUnique: booleanType()
+    }).strict();
+    fk3 = objectType({
+      name: stringType(),
+      tableFrom: stringType(),
+      columnsFrom: stringType().array(),
+      tableTo: stringType(),
+      columnsTo: stringType().array(),
+      onUpdate: stringType().optional(),
+      onDelete: stringType().optional()
+    }).strict();
+    compositePK3 = objectType({
+      columns: stringType().array(),
+      name: stringType().optional()
+    }).strict();
+    column3 = objectType({
+      name: stringType(),
+      type: stringType(),
+      primaryKey: booleanType(),
+      notNull: booleanType(),
+      autoincrement: booleanType().optional(),
+      default: anyType().optional()
+    }).strict();
+    tableV33 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column3),
+      indexes: recordType(stringType(), index3),
+      foreignKeys: recordType(stringType(), fk3)
+    }).strict();
+    uniqueConstraint3 = objectType({
+      name: stringType(),
+      columns: stringType().array()
+    }).strict();
+    table3 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column3),
+      indexes: recordType(stringType(), index3),
+      foreignKeys: recordType(stringType(), fk3),
+      compositePrimaryKeys: recordType(stringType(), compositePK3),
+      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
+    }).strict();
+    dialect2 = enumType(["sqlite"]);
+    schemaHash3 = objectType({
+      id: stringType(),
+      prevId: stringType()
+    }).strict();
+    schemaInternalV32 = objectType({
+      version: literalType("3"),
+      dialect: dialect2,
+      tables: recordType(stringType(), tableV33),
+      enums: objectType({})
+    }).strict();
+    schemaInternalV42 = objectType({
+      version: literalType("4"),
+      dialect: dialect2,
+      tables: recordType(stringType(), table3),
+      enums: objectType({})
+    }).strict();
+    latestVersion = literalType("5");
+    schemaInternal2 = objectType({
+      version: latestVersion,
+      dialect: dialect2,
+      tables: recordType(stringType(), table3),
+      enums: objectType({}),
+      _meta: objectType({
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      })
+    }).strict();
+    schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
+    schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
+    schema2 = schemaInternal2.merge(schemaHash3).strict();
+    tableSquashed3 = objectType({
+      name: stringType(),
+      columns: recordType(stringType(), column3),
+      indexes: recordType(stringType(), stringType()),
+      foreignKeys: recordType(stringType(), stringType()),
+      compositePrimaryKeys: recordType(stringType(), stringType()),
+      uniqueConstraints: recordType(stringType(), stringType()).default({})
+    }).strict();
+    schemaSquashed2 = objectType({
+      version: latestVersion,
+      dialect: dialect2,
+      tables: recordType(stringType(), tableSquashed3),
+      enums: anyType()
+    }).strict();
+    drySQLite = schema2.parse({
+      version: "5",
+      dialect: "sqlite",
+      id: originUUID,
+      prevId: "",
+      tables: {},
+      enums: {},
+      _meta: {
+        tables: {},
+        columns: {}
+      }
+    });
+  }
+});
+
+// src/utils.ts
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    init_views();
+    init_mysqlSchema();
+    init_pgSchema();
+    init_sqliteSchema();
+    init_source();
+    init_global();
+  }
+});
+
 // src/cli/views.ts
 var import_hanji;
 var init_views = __esm({
   "src/cli/views.ts"() {
+    "use strict";
     init_source();
     import_hanji = __toESM(require_hanji());
+    init_utils();
   }
 });
 
@@ -1085,6 +4770,7 @@ var init_views = __esm({
 var glob;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
+    "use strict";
     glob = __toESM(require("glob"));
     init_source();
     init_views();
@@ -1094,12 +4780,14 @@ var init_serializer = __esm({
 // src/cli/validations/outputs.ts
 var init_outputs = __esm({
   "src/cli/validations/outputs.ts"() {
+    "use strict";
     init_source();
   }
 });
 
 // src/serializer/sqliteSerializer.ts
 function mapSqlToSqliteType(sqlType) {
+  const lowered = sqlType.toLowerCase();
   if ([
     "int",
     "integer",
@@ -1111,39 +4799,43 @@ function mapSqlToSqliteType(sqlType) {
     "unsigned big int",
     "int2",
     "int8"
-  ].includes(sqlType.toLowerCase())) {
+  ].some((it) => lowered.startsWith(it))) {
     return "integer";
   } else if ([
     "character",
     "varchar",
-    "vatying character",
+    "varying character",
+    "national varying character",
     "nchar",
     "native character",
     "nvarchar",
     "text",
     "clob"
-  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
+  ].some((it) => lowered.startsWith(it))) {
+    const match2 = lowered.match(/\d+/);
+    if (match2) {
+      return `text(${match2[0]})`;
+    }
     return "text";
-  } else if (sqlType.toLowerCase() === "blob") {
+  } else if (lowered.startsWith("blob")) {
     return "blob";
-  } else if (["real", "double", "double precision", "float"].includes(
-    sqlType.toLowerCase()
-  )) {
+  } else if (["real", "double", "double precision", "float"].some((it) => lowered.startsWith(it))) {
     return "real";
   } else {
     return "numeric";
   }
 }
-var import_drizzle_orm, import_sqlite_core2, dialect, fromDatabase;
+var import_drizzle_orm, import_sqlite_core2, dialect3, fromDatabase;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
+    "use strict";
     import_drizzle_orm = require("drizzle-orm");
     import_sqlite_core2 = require("drizzle-orm/sqlite-core");
     init_serializer();
     init_outputs();
     init_source();
-    dialect = new import_sqlite_core2.SQLiteSyncDialect();
-    fromDatabase = async (db, tablesFilter = (table) => true, progressCallback) => {
+    dialect3 = new import_sqlite_core2.SQLiteSyncDialect();
+    fromDatabase = async (db, tablesFilter = (table4) => true, progressCallback) => {
       const result = {};
       const columns = await db.query(
         `SELECT 
@@ -1164,23 +4856,23 @@ var init_sqliteSerializer = __esm({
       let indexesCount = 0;
       let foreignKeysCount = 0;
       const tableToPk = {};
-      for (const column of columns) {
-        if (!tablesFilter(column.tableName))
+      for (const column4 of columns) {
+        if (!tablesFilter(column4.tableName))
           continue;
         columnsCount += 1;
         if (progressCallback) {
           progressCallback("columns", columnsCount, "fetching");
         }
-        const tableName = column.tableName;
+        const tableName = column4.tableName;
         tablesCount.add(tableName);
         if (progressCallback) {
           progressCallback("tables", tablesCount.size, "fetching");
         }
-        const columnName = column.columnName;
-        const isNotNull = column.notNull === 1;
-        const columnType = column.columnType;
-        const isPrimary = column.pk !== 0;
-        const columnDefault = column.defaultValue;
+        const columnName = column4.columnName;
+        const isNotNull = column4.notNull === 1;
+        const columnType = column4.columnType;
+        const isPrimary = column4.pk !== 0;
+        const columnDefault = column4.defaultValue;
         const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
         if (isPrimary) {
           if (typeof tableToPk[tableName] === "undefined") {
@@ -1189,7 +4881,7 @@ var init_sqliteSerializer = __esm({
             tableToPk[tableName].push(columnName);
           }
         }
-        const table = result[tableName];
+        const table4 = result[tableName];
         const newColumn = {
           default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
             columnDefault
@@ -1203,7 +4895,7 @@ var init_sqliteSerializer = __esm({
           primaryKey: false,
           notNull: isNotNull
         };
-        if (!table) {
+        if (!table4) {
           result[tableName] = {
             name: tableName,
             columns: {
@@ -1552,16 +5244,17 @@ var require_brace_expansion = __commonJS({
 });
 
 // src/serializer/pgSerializer.ts
-var import_pg_core2, import_pg_core3, import_drizzle_orm2, dialect2, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
+var import_pg_core2, import_pg_core3, import_drizzle_orm2, dialect4, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
+    "use strict";
     import_pg_core2 = require("drizzle-orm/pg-core");
     import_pg_core3 = require("drizzle-orm/pg-core");
     import_drizzle_orm2 = require("drizzle-orm");
     init_serializer();
     init_source();
     init_outputs();
-    dialect2 = new import_pg_core2.PgDialect();
+    dialect4 = new import_pg_core2.PgDialect();
     trimChar = (str, char) => {
       let start = 0;
       let end = str.length;
@@ -1571,12 +5264,12 @@ var init_pgSerializer = __esm({
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
+    fromDatabase2 = async (db, tablesFilter = () => true, schemaFilters, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
       const allTables = await db.query(
-        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
+        `SELECT table_schema, table_name FROM information_schema.tables${where === "" ? "" : ` WHERE ${where}`};`
       );
       const schemas = new Set(allTables.map((it) => it.table_schema));
       schemas.delete("public");
@@ -1596,6 +5289,35 @@ var init_pgSerializer = __esm({
       let indexesCount = 0;
       let foreignKeysCount = 0;
       let tableCount = 0;
+      const allEnums = await db.query(
+        `select n.nspname as enum_schema,
+  t.typname as enum_name,
+  e.enumlabel as enum_value,
+  e.enumsortorder as sort_order
+  from pg_type t
+  join pg_enum e on t.oid = e.enumtypid
+  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+  order by enum_schema, enum_name, sort_order;`
+      );
+      const enumsToReturn = {};
+      for (const dbEnum of allEnums) {
+        const enumName = dbEnum.enum_name;
+        const enumValue = dbEnum.enum_value;
+        const enumSchema2 = dbEnum.enum_schema || "public";
+        const key = `${enumSchema2}.${enumName}`;
+        if (enumsToReturn[key] !== void 0 && enumsToReturn[key] !== null) {
+          enumsToReturn[key].values.push(enumValue);
+        } else {
+          enumsToReturn[key] = {
+            name: enumName,
+            values: [enumValue],
+            schema: enumSchema2
+          };
+        }
+      }
+      if (progressCallback) {
+        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
+      }
       const all = allTables.map((row) => {
         return new Promise(async (res, rej) => {
           const tableName = row.table_name;
@@ -1628,7 +5350,7 @@ var init_pgSerializer = __esm({
                    WHEN 'int2'::regtype THEN 'smallserial'
                 END
            ELSE format_type(a.atttypid, a.atttypmod)
-           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt, INFORMATION_SCHEMA.COLUMNS.udt_name as enum_name
    FROM  pg_attribute  a
    JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
    WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}' and INFORMATION_SCHEMA.COLUMNS.table_schema = '${tableSchema}'
@@ -1679,14 +5401,14 @@ var init_pgSerializer = __esm({
             if (progressCallback) {
               progressCallback("fks", foreignKeysCount, "fetching");
             }
-            for (const fk of tableForeignKeys) {
-              const columnFrom = fk.column_name;
-              const tableTo = fk.foreign_table_name;
-              const columnTo = fk.foreign_column_name;
-              const schemaTo = fk.foreign_table_schema;
-              const foreignKeyName = fk.constraint_name;
-              const onUpdate = fk.update_rule.toLowerCase();
-              const onDelete = fk.delete_rule.toLowerCase();
+            for (const fk4 of tableForeignKeys) {
+              const columnFrom = fk4.column_name;
+              const tableTo = fk4.foreign_table_name;
+              const columnTo = fk4.foreign_column_name;
+              const schemaTo = fk4.foreign_table_schema;
+              const foreignKeyName = fk4.constraint_name;
+              const onUpdate = fk4.update_rule.toLowerCase();
+              const onDelete = fk4.delete_rule.toLowerCase();
               if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
                 foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
                 foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
@@ -1729,6 +5451,7 @@ var init_pgSerializer = __esm({
               const columnName = columnResponse.attname;
               const columnAdditionalDT = columnResponse.additional_dt;
               const columnDimensions = columnResponse.array_dimensions;
+              const enumType2 = columnResponse.enum_name;
               let columnType = columnResponse.data_type;
               const primaryKey = tableConstraints.filter(
                 (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
@@ -1792,7 +5515,8 @@ var init_pgSerializer = __esm({
               columnTypeMapped = trimChar(columnTypeMapped, '"');
               columnToReturn[columnName] = {
                 name: columnName,
-                type: columnTypeMapped,
+                type: columnAdditionalDT === "USER-DEFINED" ? enumType2 : columnTypeMapped,
+                typeSchema: enumsToReturn[`${tableSchema}.${enumType2}`] !== void 0 ? enumsToReturn[`${tableSchema}.${enumType2}`].schema : void 0,
                 primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
                 // default: isSerial ? undefined : defaultValue,
                 notNull: columnResponse.is_nullable === "NO"
@@ -1827,16 +5551,16 @@ var init_pgSerializer = __esm({
             );
             const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
             for (const dbIndex of dbIndexes) {
-              const indexName2 = dbIndex.index_name;
+              const indexName = dbIndex.index_name;
               const indexColumnName = dbIndex.column_name;
               const indexIsUnique = dbIndex.is_unique;
-              if (idxsInConsteraint.includes(indexName2))
+              if (idxsInConsteraint.includes(indexName))
                 continue;
-              if (typeof indexToReturn[indexName2] !== "undefined") {
-                indexToReturn[indexName2].columns.push(indexColumnName);
+              if (typeof indexToReturn[indexName] !== "undefined") {
+                indexToReturn[indexName].columns.push(indexColumnName);
               } else {
-                indexToReturn[indexName2] = {
-                  name: indexName2,
+                indexToReturn[indexName] = {
+                  name: indexName,
                   columns: [indexColumnName],
                   isUnique: indexIsUnique
                 };
@@ -1846,7 +5570,7 @@ var init_pgSerializer = __esm({
             if (progressCallback) {
               progressCallback("indexes", indexesCount, "fetching");
             }
-            result[tableName] = {
+            result[`${tableSchema}.${tableName}`] = {
               name: tableName,
               schema: tableSchema !== "public" ? tableSchema : "",
               columns: columnToReturn,
@@ -1872,33 +5596,9 @@ var init_pgSerializer = __esm({
         progressCallback("indexes", indexesCount, "done");
         progressCallback("fks", foreignKeysCount, "done");
       }
-      const allEnums = await db.query(
-        `select n.nspname as enum_schema,
-  t.typname as enum_name,
-  e.enumlabel as enum_value
-  from pg_type t
-  join pg_enum e on t.oid = e.enumtypid
-  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
-      );
-      const enumsToReturn = {};
-      for (const dbEnum of allEnums) {
-        const enumName = dbEnum.enum_name;
-        const enumValue = dbEnum.enum_value;
-        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
-          enumsToReturn[enumName].values[enumValue] = enumValue;
-        } else {
-          enumsToReturn[enumName] = {
-            name: enumName,
-            values: { [enumValue]: enumValue }
-          };
-        }
-      }
-      if (progressCallback) {
-        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
-      }
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "5",
+        version: "6",
         dialect: "pg",
         tables: result,
         enums: enumsToReturn,
@@ -1931,37 +5631,37 @@ var init_pgSerializer = __esm({
       // json: "::json",
       "character(": "::bpchar"
     };
-    defaultForColumn = (column) => {
-      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
+    defaultForColumn = (column4) => {
+      if (column4.data_type === "serial" || column4.data_type === "smallserial" || column4.data_type === "bigserial") {
         return void 0;
       }
       const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
-        (it) => column.data_type.startsWith(it)
+        (it) => column4.data_type.startsWith(it)
       );
-      if (column.column_default === null) {
+      if (column4.column_default === null) {
         return void 0;
       }
-      const columnDefaultAsString = column.column_default.toString();
+      const columnDefaultAsString = column4.column_default.toString();
       if (columnDefaultAsString.endsWith(
-        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
+        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column4.data_type
       )) {
-        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
-        const rt = column.column_default.toString().substring(1, nonPrefixPart);
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
+        const nonPrefixPart = column4.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column4.data_type}`).length - 1;
+        const rt = column4.column_default.toString().substring(1, nonPrefixPart);
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column4.data_type.startsWith("numeric")) {
           return Number(rt);
-        } else if (column.data_type === "json" || column.data_type === "jsonb") {
+        } else if (column4.data_type === "json" || column4.data_type === "jsonb") {
           const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
-          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
+          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column4.data_type}`}`;
+        } else if (column4.data_type === "boolean") {
+          return column4.column_default === "true";
         } else {
           return `'${rt}'`;
         }
       } else {
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column4.data_type.startsWith("numeric")) {
           return Number(columnDefaultAsString);
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
+        } else if (column4.data_type === "boolean") {
+          return column4.column_default === "true";
         } else {
           return `${columnDefaultAsString}`;
         }
@@ -1970,43 +5670,9 @@ var init_pgSerializer = __esm({
   }
 });
 
-// src/drivers/index.ts
-var import_drizzle_orm4, DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
-var init_drivers = __esm({
-  "src/drivers/index.ts"() {
-    import_drizzle_orm4 = require("drizzle-orm");
-    DrizzleDbClient = class {
-      constructor(db) {
-        this.db = db;
-      }
-    };
-    DrizzleORMPgClient = class extends DrizzleDbClient {
-      async query(query, values) {
-        const res = await this.db.execute(import_drizzle_orm4.sql.raw(query));
-        return res.rows;
-      }
-      async run(query) {
-        const res = await this.db.execute(import_drizzle_orm4.sql.raw(query));
-        return res.rows;
-      }
-    };
-    TursoSqlite = class extends DrizzleDbClient {
-      async run(query) {
-        await this.db.execute(query);
-      }
-      async query(query) {
-        const res = await this.db.execute(query);
-        return res.rows;
-      }
-    };
-  }
-});
-
 // src/utils-studio.ts
 var utils_studio_exports = {};
 __export(utils_studio_exports, {
-  DrizzleORMPgClient: () => DrizzleORMPgClient,
-  TursoSqlite: () => TursoSqlite,
   drizzleSchemaPg: () => pgSchemaToDrizzle,
   drizzleSchemaSQLite: () => sqliteSchemaToDrizzle,
   pgPushIntrospect: () => pgPushIntrospect,
@@ -2017,9 +5683,9 @@ module.exports = __toCommonJS(utils_studio_exports);
 // src/serializer/schemaToDrizzle.ts
 var import_pg_core = require("drizzle-orm/pg-core");
 var import_sqlite_core = require("drizzle-orm/sqlite-core");
-var pgSchemaToDrizzle = (schema, schemaName) => {
+var pgSchemaToDrizzle = (schema3, schemaName) => {
   const tables = {};
-  Object.values(schema.tables).forEach((t) => {
+  Object.values(schema3.tables).forEach((t) => {
     const columns = {};
     Object.values(t.columns).forEach((c) => {
       const columnName = c.name;
@@ -2119,9 +5785,9 @@ var pgSchemaToDrizzle = (schema, schemaName) => {
   });
   return tables;
 };
-var sqliteSchemaToDrizzle = (schema) => {
+var sqliteSchemaToDrizzle = (schema3) => {
   const tables = {};
-  Object.values(schema.tables).forEach((t) => {
+  Object.values(schema3.tables).forEach((t) => {
     const columns = {};
     Object.values(t.columns).forEach((c) => {
       const columnName = c.name;
@@ -2166,11 +5832,7 @@ var sqliteSchemaToDrizzle = (schema) => {
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
-
-// src/global.ts
-var originUUID = "00000000-0000-0000-0000-000000000000";
-
-// src/cli/commands/sqliteIntrospect.ts
+init_global();
 init_sqliteSerializer();
 
 // node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
@@ -2187,17 +5849,17 @@ var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUp
   let isLastCharUpper = false;
   let isLastLastCharUpper = false;
   let isLastLastCharPreserved = false;
-  for (let index = 0; index < string.length; index++) {
-    const character = string[index];
-    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+  for (let index4 = 0; index4 < string.length; index4++) {
+    const character = string[index4];
+    isLastLastCharPreserved = index4 > 2 ? string[index4 - 3] === "-" : true;
     if (isLastCharLower && UPPERCASE.test(character)) {
-      string = string.slice(0, index) + "-" + string.slice(index);
+      string = string.slice(0, index4) + "-" + string.slice(index4);
       isLastCharLower = false;
       isLastLastCharUpper = isLastCharUpper;
       isLastCharUpper = true;
-      index++;
+      index4++;
     } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) {
-      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+      string = string.slice(0, index4 - 1) + "-" + string.slice(index4 - 1);
       isLastLastCharUpper = isLastCharUpper;
       isLastCharUpper = false;
       isLastCharLower = true;
@@ -2272,7 +5934,7 @@ String.prototype.camelCase = function() {
   return camelCase(String(this));
 };
 String.prototype.concatIf = function(it, condition) {
-  return condition ? `${this}${it}` : this;
+  return condition ? `${this}${it}` : String(this);
 };
 Array.prototype.random = function() {
   return this[~~(Math.random() * this.length)];
@@ -3326,7 +6988,7 @@ minimatch.unescape = unescape;
 
 // src/cli/commands/sqliteIntrospect.ts
 var import_hanji2 = __toESM(require_hanji());
-var sqlitePushIntrospect = async (client, filters) => {
+var sqlitePushIntrospect = async (db, filters) => {
   const matchers = filters.map((it) => {
     return new Minimatch(it);
   });
@@ -3340,24 +7002,15 @@ var sqlitePushIntrospect = async (client, filters) => {
     }
     return false;
   };
-  const res = await fromDatabase(client, filter2);
-  const schema = { id: originUUID, prevId: "", ...res };
-  return { schema };
+  const res = await fromDatabase(db, filter2);
+  const schema3 = { id: originUUID, prevId: "", ...res };
+  return { schema: schema3 };
 };
 
 // src/cli/commands/pgIntrospect.ts
-var import_hanji3 = __toESM(require_hanji());
-init_views();
-init_pgSerializer();
-
-// src/introspect-pg.ts
-var import_drizzle_orm3 = require("drizzle-orm");
-var import_relations = require("drizzle-orm/relations");
 init_pgSerializer();
-
-// src/cli/commands/pgIntrospect.ts
-var pgPushIntrospect = async (connection, filters, schemaFilters) => {
-  const { client } = connection;
+init_global();
+var pgPushIntrospect = async (db, filters, schemaFilters) => {
   const matchers = filters.map((it) => {
     return new Minimatch(it);
   });
@@ -3371,18 +7024,13 @@ var pgPushIntrospect = async (connection, filters, schemaFilters) => {
     }
     return false;
   };
-  const res = await fromDatabase2(client, filter2, schemaFilters);
-  const schema = { id: originUUID, prevId: "", ...res };
-  const { internal, ...schemaWithoutInternals } = schema;
+  const res = await fromDatabase2(db, filter2, schemaFilters);
+  const schema3 = { id: originUUID, prevId: "", ...res };
+  const { internal, ...schemaWithoutInternals } = schema3;
   return { schema: schemaWithoutInternals };
 };
-
-// src/utils-studio.ts
-init_drivers();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DrizzleORMPgClient,
-  TursoSqlite,
   drizzleSchemaPg,
   drizzleSchemaSQLite,
   pgPushIntrospect,