@coursebuilder/adapter-drizzle 0.0.5 → 0.0.6

package/dist/{chunk-JQFZOCAU.js → chunk-FRNVLW7N.js}

@@ -34,7 +34,7 @@ import {
 import {
   getSessionRelationsSchema,
   getSessionsSchema
-} from "./chunk-NISOQSUL.js";
+} from "./chunk-PFN4YUQZ.js";
 import {
   getVerificationTokensSchema
 } from "./chunk-TMQIGK3N.js";
@@ -69,7 +69,7 @@ import {
   getUserRolesSchema,
   getUsersRelationsSchema,
   getUsersSchema
-} from "./chunk-PUGK2AEH.js";
+} from "./chunk-4HDU7QIB.js";
 import {
   getCommunicationChannelSchema
 } from "./chunk-6CBAFOL3.js";
@@ -85,18 +85,27 @@ import { addSeconds, isAfter } from "date-fns";
 import { and, eq, sql } from "drizzle-orm";
 import { mysqlTable as defaultMySqlTableFn } from "drizzle-orm/mysql-core";
 
-// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
+// ../core/dist/chunk-DFHEFTJZ.js
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+
+// ../core/dist/chunk-EK2ZQYRJ.js
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
   function assertIs(_arg) {
   }
   __name(assertIs, "assertIs");
+  __name2(assertIs, "assertIs");
   util2.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error();
   }
   __name(assertNever, "assertNever");
+  __name2(assertNever, "assertNever");
   util2.assertNever = assertNever;
   util2.arrayToEnum = (items) => {
     const obj = {};
@@ -139,6 +148,7 @@ var util;
     return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
   __name(joinValues, "joinValues");
+  __name2(joinValues, "joinValues");
   util2.joinValues = joinValues;
   util2.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
@@ -153,7 +163,6 @@ var objectUtil;
     return {
       ...first,
       ...second
-      // second overwrites first
     };
   };
 })(objectUtil || (objectUtil = {}));
@@ -179,7 +188,7 @@ var ZodParsedType = util.arrayToEnum([
   "map",
   "set"
 ]);
-var getParsedType = /* @__PURE__ */ __name((data) => {
+var getParsedType = /* @__PURE__ */ __name2((data) => {
   const t = typeof data;
   switch (t) {
     case "undefined":
@@ -238,19 +247,25 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
-var quotelessJson = /* @__PURE__ */ __name((obj) => {
+var quotelessJson = /* @__PURE__ */ __name2((obj) => {
   const json = JSON.stringify(obj, null, 2);
   return json.replace(/"([^"]+)":/g, "$1:");
 }, "quotelessJson");
-var ZodError = class extends Error {
+var ZodError = /* @__PURE__ */ __name(class extends Error {
   constructor(issues) {
     super();
     this.issues = [];
     this.addIssue = (sub) => {
-      this.issues = [...this.issues, sub];
+      this.issues = [
+        ...this.issues,
+        sub
+      ];
     };
     this.addIssues = (subs = []) => {
-      this.issues = [...this.issues, ...subs];
+      this.issues = [
+        ...this.issues,
+        ...subs
+      ];
     };
     const actualProto = new.target.prototype;
     if (Object.setPrototypeOf) {
@@ -268,8 +283,10 @@ var ZodError = class extends Error {
     const mapper = _mapper || function(issue) {
       return issue.message;
     };
-    const fieldErrors = { _errors: [] };
-    const processError = /* @__PURE__ */ __name((error) => {
+    const fieldErrors = {
+      _errors: []
+    };
+    const processError = /* @__PURE__ */ __name2((error) => {
       for (const issue of error.issues) {
         if (issue.code === "invalid_union") {
           issue.unionErrors.map(processError);
@@ -286,9 +303,13 @@ var ZodError = class extends Error {
             const el = issue.path[i];
             const terminal = i === issue.path.length - 1;
             if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
+              curr[el] = curr[el] || {
+                _errors: []
+              };
             } else {
-              curr[el] = curr[el] || { _errors: [] };
+              curr[el] = curr[el] || {
+                _errors: []
+              };
               curr[el]._errors.push(mapper(issue));
             }
             curr = curr[el];
@@ -320,18 +341,21 @@ var ZodError = class extends Error {
         formErrors.push(mapper(sub));
       }
     }
-    return { formErrors, fieldErrors };
+    return {
+      formErrors,
+      fieldErrors
+    };
   }
   get formErrors() {
     return this.flatten();
   }
-};
-__name(ZodError, "ZodError");
+}, "ZodError");
+__name2(ZodError, "ZodError");
 ZodError.create = (issues) => {
   const error = new ZodError(issues);
   return error;
 };
-var errorMap = /* @__PURE__ */ __name((issue, _ctx) => {
+var errorMap = /* @__PURE__ */ __name2((issue, _ctx) => {
   let message;
   switch (issue.code) {
     case ZodIssueCode.invalid_type:
@@ -427,20 +451,27 @@ var errorMap = /* @__PURE__ */ __name((issue, _ctx) => {
       message = _ctx.defaultError;
       util.assertNever(issue);
   }
-  return { message };
+  return {
+    message
+  };
 }, "errorMap");
 var overrideErrorMap = errorMap;
 function setErrorMap(map) {
   overrideErrorMap = map;
 }
 __name(setErrorMap, "setErrorMap");
+__name2(setErrorMap, "setErrorMap");
 function getErrorMap() {
   return overrideErrorMap;
 }
 __name(getErrorMap, "getErrorMap");
-var makeIssue = /* @__PURE__ */ __name((params) => {
+__name2(getErrorMap, "getErrorMap");
+var makeIssue = /* @__PURE__ */ __name2((params) => {
   const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const fullPath = [
+    ...path,
+    ...issueData.path || []
+  ];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -448,7 +479,10 @@ var makeIssue = /* @__PURE__ */ __name((params) => {
   let errorMessage = "";
   const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map of maps) {
-    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+    errorMessage = map(fullIssue, {
+      data,
+      defaultError: errorMessage
+    }).message;
   }
   return {
     ...issueData,
@@ -467,13 +501,13 @@ function addIssueToContext(ctx, issueData) {
       ctx.schemaErrorMap,
       getErrorMap(),
       errorMap
-      // then global default map
     ].filter((x) => !!x)
   });
   ctx.common.issues.push(issue);
 }
 __name(addIssueToContext, "addIssueToContext");
-var ParseStatus = class {
+__name2(addIssueToContext, "addIssueToContext");
+var ParseStatus = /* @__PURE__ */ __name(class {
   constructor() {
     this.value = "valid";
   }
@@ -494,7 +528,10 @@ var ParseStatus = class {
         status.dirty();
       arrayValue.push(s.value);
     }
-    return { status: status.value, value: arrayValue };
+    return {
+      status: status.value,
+      value: arrayValue
+    };
   }
   static async mergeObjectAsync(status, pairs) {
     const syncPairs = [];
@@ -522,25 +559,36 @@ var ParseStatus = class {
         finalObject[key.value] = value.value;
       }
     }
-    return { status: status.value, value: finalObject };
+    return {
+      status: status.value,
+      value: finalObject
+    };
   }
-};
-__name(ParseStatus, "ParseStatus");
+}, "ParseStatus");
+__name2(ParseStatus, "ParseStatus");
 var INVALID = Object.freeze({
   status: "aborted"
 });
-var DIRTY = /* @__PURE__ */ __name((value) => ({ status: "dirty", value }), "DIRTY");
-var OK = /* @__PURE__ */ __name((value) => ({ status: "valid", value }), "OK");
-var isAborted = /* @__PURE__ */ __name((x) => x.status === "aborted", "isAborted");
-var isDirty = /* @__PURE__ */ __name((x) => x.status === "dirty", "isDirty");
-var isValid = /* @__PURE__ */ __name((x) => x.status === "valid", "isValid");
-var isAsync = /* @__PURE__ */ __name((x) => typeof Promise !== "undefined" && x instanceof Promise, "isAsync");
+var DIRTY = /* @__PURE__ */ __name2((value) => ({
+  status: "dirty",
+  value
+}), "DIRTY");
+var OK = /* @__PURE__ */ __name2((value) => ({
+  status: "valid",
+  value
+}), "OK");
+var isAborted = /* @__PURE__ */ __name2((x) => x.status === "aborted", "isAborted");
+var isDirty = /* @__PURE__ */ __name2((x) => x.status === "dirty", "isDirty");
+var isValid = /* @__PURE__ */ __name2((x) => x.status === "valid", "isValid");
+var isAsync = /* @__PURE__ */ __name2((x) => typeof Promise !== "undefined" && x instanceof Promise, "isAsync");
 var errorUtil;
 (function(errorUtil2) {
-  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+  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 = {}));
-var ParseInputLazyPath = class {
+var ParseInputLazyPath = /* @__PURE__ */ __name(class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
     this.parent = parent;
@@ -558,11 +606,14 @@ var ParseInputLazyPath = class {
     }
     return this._cachedPath;
   }
-};
-__name(ParseInputLazyPath, "ParseInputLazyPath");
-var handleResult = /* @__PURE__ */ __name((ctx, result) => {
+}, "ParseInputLazyPath");
+__name2(ParseInputLazyPath, "ParseInputLazyPath");
+var handleResult = /* @__PURE__ */ __name2((ctx, result) => {
   if (isValid(result)) {
-    return { success: true, data: result.value };
+    return {
+      success: true,
+      data: result.value
+    };
   } else {
     if (!ctx.common.issues.length) {
       throw new Error("Validation failed but no issues detected.");
@@ -587,19 +638,32 @@ function processCreateParams(params) {
     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 = /* @__PURE__ */ __name((iss, ctx) => {
+    return {
+      errorMap: errorMap2,
+      description
+    };
+  const customMap = /* @__PURE__ */ __name2((iss, ctx) => {
     if (iss.code !== "invalid_type")
-      return { message: ctx.defaultError };
+      return {
+        message: ctx.defaultError
+      };
     if (typeof ctx.data === "undefined") {
-      return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+      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 {
+      message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError
+    };
   }, "customMap");
-  return { errorMap: customMap, description };
+  return {
+    errorMap: customMap,
+    description
+  };
 }
 __name(processCreateParams, "processCreateParams");
-var ZodType = class {
+__name2(processCreateParams, "processCreateParams");
+var ZodType = /* @__PURE__ */ __name(class {
   constructor(def) {
     this.spa = this.safeParseAsync;
     this._def = def;
@@ -688,7 +752,11 @@ var ZodType = class {
       data,
       parsedType: getParsedType(data)
     };
-    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+    const result = this._parseSync({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
     return handleResult(ctx, result);
   }
   async parseAsync(data, params) {
@@ -710,14 +778,20 @@ var ZodType = class {
       data,
       parsedType: getParsedType(data)
     };
-    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
+    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 = /* @__PURE__ */ __name((val) => {
+    const getIssueProperties = /* @__PURE__ */ __name2((val) => {
       if (typeof message === "string" || typeof message === "undefined") {
-        return { message };
+        return {
+          message
+        };
       } else if (typeof message === "function") {
         return message(val);
       } else {
@@ -726,7 +800,7 @@ var ZodType = class {
     }, "getIssueProperties");
     return this._refinement((val, ctx) => {
       const result = check(val);
-      const setError = /* @__PURE__ */ __name(() => ctx.addIssue({
+      const setError = /* @__PURE__ */ __name2(() => ctx.addIssue({
         code: ZodIssueCode.custom,
         ...getIssueProperties(val)
       }), "setError");
@@ -762,7 +836,10 @@ var ZodType = class {
     return new ZodEffects({
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "refinement", refinement }
+      effect: {
+        type: "refinement",
+        refinement
+      }
     });
   }
   superRefine(refinement) {
@@ -784,7 +861,10 @@ var ZodType = class {
     return ZodPromise.create(this, this._def);
   }
   or(option) {
-    return ZodUnion.create([this, option], this._def);
+    return ZodUnion.create([
+      this,
+      option
+    ], this._def);
   }
   and(incoming) {
     return ZodIntersection.create(this, incoming, this._def);
@@ -794,7 +874,10 @@ var ZodType = class {
       ...processCreateParams(this._def),
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "transform", transform }
+      effect: {
+        type: "transform",
+        transform
+      }
     });
   }
   default(def) {
@@ -841,8 +924,8 @@ var ZodType = class {
   isNullable() {
     return this.safeParse(null).success;
   }
-};
-__name(ZodType, "ZodType");
+}, "ZodType");
+__name2(ZodType, "ZodType");
 var cuidRegex = /^c[^\s-]{8,}$/i;
 var cuid2Regex = /^[a-z][a-z0-9]*$/;
 var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/;
@@ -852,7 +935,7 @@ var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
 var emojiRegex;
 var ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
 var ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
-var datetimeRegex = /* @__PURE__ */ __name((args) => {
+var datetimeRegex = /* @__PURE__ */ __name2((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)$`);
@@ -883,7 +966,8 @@ function isValidIP(ip, version) {
   return false;
 }
 __name(isValidIP, "isValidIP");
-var ZodString = class extends ZodType {
+__name2(isValidIP, "isValidIP");
+var ZodString = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     if (this._def.coerce) {
       input.data = String(input.data);
@@ -891,15 +975,11 @@ var ZodString = class extends ZodType {
     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
-        }
-        //
-      );
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx2.parsedType
+      });
       return INVALID;
     }
     const status = new ParseStatus();
@@ -1051,7 +1131,10 @@ var ZodString = class extends ZodType {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
-            validation: { includes: check.value, position: check.position },
+            validation: {
+              includes: check.value,
+              position: check.position
+            },
             message: check.message
           });
           status.dirty();
@@ -1065,7 +1148,9 @@ var ZodString = class extends ZodType {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
-            validation: { startsWith: check.value },
+            validation: {
+              startsWith: check.value
+            },
             message: check.message
           });
           status.dirty();
@@ -1075,7 +1160,9 @@ var ZodString = class extends ZodType {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
-            validation: { endsWith: check.value },
+            validation: {
+              endsWith: check.value
+            },
             message: check.message
           });
           status.dirty();
@@ -1105,7 +1192,10 @@ var ZodString = class extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return {
+      status: status.value,
+      value: input.data
+    };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -1117,32 +1207,59 @@ var ZodString = class extends ZodType {
   _addCheck(check) {
     return new ZodString({
       ...this._def,
-      checks: [...this._def.checks, check]
+      checks: [
+        ...this._def.checks,
+        check
+      ]
     });
   }
   email(message) {
-    return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "email",
+      ...errorUtil.errToObj(message)
+    });
   }
   url(message) {
-    return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "url",
+      ...errorUtil.errToObj(message)
+    });
   }
   emoji(message) {
-    return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "emoji",
+      ...errorUtil.errToObj(message)
+    });
   }
   uuid(message) {
-    return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "uuid",
+      ...errorUtil.errToObj(message)
+    });
   }
   cuid(message) {
-    return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "cuid",
+      ...errorUtil.errToObj(message)
+    });
   }
   cuid2(message) {
-    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "cuid2",
+      ...errorUtil.errToObj(message)
+    });
   }
   ulid(message) {
-    return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
+    return this._addCheck({
+      kind: "ulid",
+      ...errorUtil.errToObj(message)
+    });
   }
   ip(options) {
-    return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
+    return this._addCheck({
+      kind: "ip",
+      ...errorUtil.errToObj(options)
+    });
   }
   datetime(options) {
     var _a;
@@ -1212,28 +1329,43 @@ var ZodString = class extends ZodType {
     });
   }
   /**
-   * @deprecated Use z.string().min(1) instead.
-   * @see {@link ZodString.min}
-   */
+  * @deprecated Use z.string().min(1) instead.
+  * @see {@link ZodString.min}
+  */
   nonempty(message) {
     return this.min(1, errorUtil.errToObj(message));
   }
   trim() {
     return new ZodString({
       ...this._def,
-      checks: [...this._def.checks, { kind: "trim" }]
+      checks: [
+        ...this._def.checks,
+        {
+          kind: "trim"
+        }
+      ]
     });
   }
   toLowerCase() {
     return new ZodString({
       ...this._def,
-      checks: [...this._def.checks, { kind: "toLowerCase" }]
+      checks: [
+        ...this._def.checks,
+        {
+          kind: "toLowerCase"
+        }
+      ]
     });
   }
   toUpperCase() {
     return new ZodString({
       ...this._def,
-      checks: [...this._def.checks, { kind: "toUpperCase" }]
+      checks: [
+        ...this._def.checks,
+        {
+          kind: "toUpperCase"
+        }
+      ]
     });
   }
   get isDatetime() {
@@ -1283,8 +1415,8 @@ var ZodString = class extends ZodType {
     }
     return max;
   }
-};
-__name(ZodString, "ZodString");
+}, "ZodString");
+__name2(ZodString, "ZodString");
 ZodString.create = (params) => {
   var _a;
   return new ZodString({
@@ -1303,7 +1435,8 @@ function floatSafeRemainder(val, step) {
   return valInt % stepInt / Math.pow(10, decCount);
 }
 __name(floatSafeRemainder, "floatSafeRemainder");
-var ZodNumber = class extends ZodType {
+__name2(floatSafeRemainder, "floatSafeRemainder");
+var ZodNumber = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this.min = this.gte;
@@ -1389,7 +1522,10 @@ var ZodNumber = class extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return {
+      status: status.value,
+      value: input.data
+    };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -1420,7 +1556,10 @@ var ZodNumber = class extends ZodType {
   _addCheck(check) {
     return new ZodNumber({
       ...this._def,
-      checks: [...this._def.checks, check]
+      checks: [
+        ...this._def.checks,
+        check
+      ]
     });
   }
   int(message) {
@@ -1525,8 +1664,8 @@ var ZodNumber = class extends ZodType {
     }
     return Number.isFinite(min) && Number.isFinite(max);
   }
-};
-__name(ZodNumber, "ZodNumber");
+}, "ZodNumber");
+__name2(ZodNumber, "ZodNumber");
 ZodNumber.create = (params) => {
   return new ZodNumber({
     checks: [],
@@ -1535,7 +1674,7 @@ ZodNumber.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var ZodBigInt = class extends ZodType {
+var ZodBigInt = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this.min = this.gte;
@@ -1598,7 +1737,10 @@ var ZodBigInt = class extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return {
+      status: status.value,
+      value: input.data
+    };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -1629,7 +1771,10 @@ var ZodBigInt = class extends ZodType {
   _addCheck(check) {
     return new ZodBigInt({
       ...this._def,
-      checks: [...this._def.checks, check]
+      checks: [
+        ...this._def.checks,
+        check
+      ]
     });
   }
   positive(message) {
@@ -1691,8 +1836,8 @@ var ZodBigInt = class extends ZodType {
     }
     return max;
   }
-};
-__name(ZodBigInt, "ZodBigInt");
+}, "ZodBigInt");
+__name2(ZodBigInt, "ZodBigInt");
 ZodBigInt.create = (params) => {
   var _a;
   return new ZodBigInt({
@@ -1702,7 +1847,7 @@ ZodBigInt.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var ZodBoolean = class extends ZodType {
+var ZodBoolean = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     if (this._def.coerce) {
       input.data = Boolean(input.data);
@@ -1719,8 +1864,8 @@ var ZodBoolean = class extends ZodType {
     }
     return OK(input.data);
   }
-};
-__name(ZodBoolean, "ZodBoolean");
+}, "ZodBoolean");
+__name2(ZodBoolean, "ZodBoolean");
 ZodBoolean.create = (params) => {
   return new ZodBoolean({
     typeName: ZodFirstPartyTypeKind.ZodBoolean,
@@ -1728,7 +1873,7 @@ ZodBoolean.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var ZodDate = class extends ZodType {
+var ZodDate = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     if (this._def.coerce) {
       input.data = new Date(input.data);
@@ -1791,7 +1936,10 @@ var ZodDate = class extends ZodType {
   _addCheck(check) {
     return new ZodDate({
       ...this._def,
-      checks: [...this._def.checks, check]
+      checks: [
+        ...this._def.checks,
+        check
+      ]
     });
   }
   min(minDate, message) {
@@ -1828,8 +1976,8 @@ var ZodDate = class extends ZodType {
     }
     return max != null ? new Date(max) : null;
   }
-};
-__name(ZodDate, "ZodDate");
+}, "ZodDate");
+__name2(ZodDate, "ZodDate");
 ZodDate.create = (params) => {
   return new ZodDate({
     checks: [],
@@ -1838,7 +1986,7 @@ ZodDate.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var ZodSymbol = class extends ZodType {
+var ZodSymbol = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.symbol) {
@@ -1852,15 +2000,15 @@ var ZodSymbol = class extends ZodType {
     }
     return OK(input.data);
   }
-};
-__name(ZodSymbol, "ZodSymbol");
+}, "ZodSymbol");
+__name2(ZodSymbol, "ZodSymbol");
 ZodSymbol.create = (params) => {
   return new ZodSymbol({
     typeName: ZodFirstPartyTypeKind.ZodSymbol,
     ...processCreateParams(params)
   });
 };
-var ZodUndefined = class extends ZodType {
+var ZodUndefined = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
@@ -1874,15 +2022,15 @@ var ZodUndefined = class extends ZodType {
     }
     return OK(input.data);
   }
-};
-__name(ZodUndefined, "ZodUndefined");
+}, "ZodUndefined");
+__name2(ZodUndefined, "ZodUndefined");
 ZodUndefined.create = (params) => {
   return new ZodUndefined({
     typeName: ZodFirstPartyTypeKind.ZodUndefined,
     ...processCreateParams(params)
   });
 };
-var ZodNull = class extends ZodType {
+var ZodNull = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.null) {
@@ -1896,15 +2044,15 @@ var ZodNull = class extends ZodType {
     }
     return OK(input.data);
   }
-};
-__name(ZodNull, "ZodNull");
+}, "ZodNull");
+__name2(ZodNull, "ZodNull");
 ZodNull.create = (params) => {
   return new ZodNull({
     typeName: ZodFirstPartyTypeKind.ZodNull,
     ...processCreateParams(params)
   });
 };
-var ZodAny = class extends ZodType {
+var ZodAny = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this._any = true;
@@ -1912,15 +2060,15 @@ var ZodAny = class extends ZodType {
   _parse(input) {
     return OK(input.data);
   }
-};
-__name(ZodAny, "ZodAny");
+}, "ZodAny");
+__name2(ZodAny, "ZodAny");
 ZodAny.create = (params) => {
   return new ZodAny({
     typeName: ZodFirstPartyTypeKind.ZodAny,
     ...processCreateParams(params)
   });
 };
-var ZodUnknown = class extends ZodType {
+var ZodUnknown = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this._unknown = true;
@@ -1928,15 +2076,15 @@ var ZodUnknown = class extends ZodType {
   _parse(input) {
     return OK(input.data);
   }
-};
-__name(ZodUnknown, "ZodUnknown");
+}, "ZodUnknown");
+__name2(ZodUnknown, "ZodUnknown");
 ZodUnknown.create = (params) => {
   return new ZodUnknown({
     typeName: ZodFirstPartyTypeKind.ZodUnknown,
     ...processCreateParams(params)
   });
 };
-var ZodNever = class extends ZodType {
+var ZodNever = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const ctx = this._getOrReturnCtx(input);
     addIssueToContext(ctx, {
@@ -1946,15 +2094,15 @@ var ZodNever = class extends ZodType {
     });
     return INVALID;
   }
-};
-__name(ZodNever, "ZodNever");
+}, "ZodNever");
+__name2(ZodNever, "ZodNever");
 ZodNever.create = (params) => {
   return new ZodNever({
     typeName: ZodFirstPartyTypeKind.ZodNever,
     ...processCreateParams(params)
   });
 };
-var ZodVoid = class extends ZodType {
+var ZodVoid = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
@@ -1968,15 +2116,15 @@ var ZodVoid = class extends ZodType {
     }
     return OK(input.data);
   }
-};
-__name(ZodVoid, "ZodVoid");
+}, "ZodVoid");
+__name2(ZodVoid, "ZodVoid");
 ZodVoid.create = (params) => {
   return new ZodVoid({
     typeName: ZodFirstPartyTypeKind.ZodVoid,
     ...processCreateParams(params)
   });
 };
-var ZodArray = class extends ZodType {
+var ZodArray = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx, status } = this._processInputParams(input);
     const def = this._def;
@@ -2031,13 +2179,17 @@ var ZodArray = class extends ZodType {
       }
     }
     if (ctx.common.async) {
-      return Promise.all([...ctx.data].map((item, i) => {
+      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) => {
+    const result = [
+      ...ctx.data
+    ].map((item, i) => {
       return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
     return ParseStatus.mergeArray(status, result);
@@ -2048,26 +2200,35 @@ var ZodArray = class extends ZodType {
   min(minLength, message) {
     return new ZodArray({
       ...this._def,
-      minLength: { value: minLength, message: errorUtil.toString(message) }
+      minLength: {
+        value: minLength,
+        message: errorUtil.toString(message)
+      }
     });
   }
   max(maxLength, message) {
     return new ZodArray({
       ...this._def,
-      maxLength: { value: maxLength, message: errorUtil.toString(message) }
+      maxLength: {
+        value: maxLength,
+        message: errorUtil.toString(message)
+      }
     });
   }
   length(len, message) {
     return new ZodArray({
       ...this._def,
-      exactLength: { value: len, message: errorUtil.toString(message) }
+      exactLength: {
+        value: len,
+        message: errorUtil.toString(message)
+      }
     });
   }
   nonempty(message) {
     return this.min(1, message);
   }
-};
-__name(ZodArray, "ZodArray");
+}, "ZodArray");
+__name2(ZodArray, "ZodArray");
 ZodArray.create = (schema, params) => {
   return new ZodArray({
     type: schema,
@@ -2105,7 +2266,8 @@ function deepPartialify(schema) {
   }
 }
 __name(deepPartialify, "deepPartialify");
-var ZodObject = class extends ZodType {
+__name2(deepPartialify, "deepPartialify");
+var ZodObject = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this._cached = null;
@@ -2117,7 +2279,10 @@ var ZodObject = class extends ZodType {
       return this._cached;
     const shape = this._def.shape();
     const keys = util.objectKeys(shape);
-    return this._cached = { shape, keys };
+    return this._cached = {
+      shape,
+      keys
+    };
   }
   _parse(input) {
     const parsedType = this._getType(input);
@@ -2145,7 +2310,10 @@ var ZodObject = class extends ZodType {
       const keyValidator = shape[key];
       const value = ctx.data[key];
       pairs.push({
-        key: { status: "valid", value: key },
+        key: {
+          status: "valid",
+          value: key
+        },
         value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
         alwaysSet: key in ctx.data
       });
@@ -2155,8 +2323,14 @@ var ZodObject = class extends ZodType {
       if (unknownKeys === "passthrough") {
         for (const key of extraKeys) {
           pairs.push({
-            key: { status: "valid", value: key },
-            value: { status: "valid", value: ctx.data[key] }
+            key: {
+              status: "valid",
+              value: key
+            },
+            value: {
+              status: "valid",
+              value: ctx.data[key]
+            }
           });
         }
       } else if (unknownKeys === "strict") {
@@ -2177,11 +2351,11 @@ var ZodObject = class extends ZodType {
       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)
-          ),
+          key: {
+            status: "valid",
+            value: key
+          },
+          value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
           alwaysSet: key in ctx.data
         });
       }
@@ -2267,10 +2441,10 @@ var ZodObject = class extends ZodType {
     });
   }
   /**
-   * Prior to zod@1.0.12 there was a bug in the
-   * inferred type of merged objects. Please
-   * upgrade if you are experiencing issues.
-   */
+  * 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,
@@ -2319,7 +2493,9 @@ var ZodObject = class extends ZodType {
   //   return merged;
   // }
   setKey(key, schema) {
-    return this.augment({ [key]: schema });
+    return this.augment({
+      [key]: schema
+    });
   }
   // merge<Incoming extends AnyZodObject>(
   //   merging: Incoming
@@ -2373,8 +2549,8 @@ var ZodObject = class extends ZodType {
     });
   }
   /**
-   * @deprecated
-   */
+  * @deprecated
+  */
   deepPartial() {
     return deepPartialify(this);
   }
@@ -2415,8 +2591,8 @@ var ZodObject = class extends ZodType {
   keyof() {
     return createZodEnum(util.objectKeys(this.shape));
   }
-};
-__name(ZodObject, "ZodObject");
+}, "ZodObject");
+__name2(ZodObject, "ZodObject");
 ZodObject.create = (shape, params) => {
   return new ZodObject({
     shape: () => shape,
@@ -2444,7 +2620,7 @@ ZodObject.lazycreate = (shape, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodUnion = class extends ZodType {
+var ZodUnion = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const options = this._def.options;
@@ -2468,6 +2644,7 @@ var ZodUnion = class extends ZodType {
       return INVALID;
     }
     __name(handleResults, "handleResults");
+    __name2(handleResults, "handleResults");
     if (ctx.common.async) {
       return Promise.all(options.map(async (option) => {
         const childCtx = {
@@ -2507,7 +2684,10 @@ var ZodUnion = class extends ZodType {
         if (result.status === "valid") {
           return result;
         } else if (result.status === "dirty" && !dirty) {
-          dirty = { result, ctx: childCtx };
+          dirty = {
+            result,
+            ctx: childCtx
+          };
         }
         if (childCtx.common.issues.length) {
           issues.push(childCtx.common.issues);
@@ -2528,8 +2708,8 @@ var ZodUnion = class extends ZodType {
   get options() {
     return this._def.options;
   }
-};
-__name(ZodUnion, "ZodUnion");
+}, "ZodUnion");
+__name2(ZodUnion, "ZodUnion");
 ZodUnion.create = (types, params) => {
   return new ZodUnion({
     options: types,
@@ -2537,13 +2717,15 @@ ZodUnion.create = (types, params) => {
     ...processCreateParams(params)
   });
 };
-var getDiscriminator = /* @__PURE__ */ __name((type) => {
+var getDiscriminator = /* @__PURE__ */ __name2((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];
+    return [
+      type.value
+    ];
   } else if (type instanceof ZodEnum) {
     return type.options;
   } else if (type instanceof ZodNativeEnum) {
@@ -2551,14 +2733,18 @@ var getDiscriminator = /* @__PURE__ */ __name((type) => {
   } else if (type instanceof ZodDefault) {
     return getDiscriminator(type._def.innerType);
   } else if (type instanceof ZodUndefined) {
-    return [void 0];
+    return [
+      void 0
+    ];
   } else if (type instanceof ZodNull) {
-    return [null];
+    return [
+      null
+    ];
   } else {
     return null;
   }
 }, "getDiscriminator");
-var ZodDiscriminatedUnion = class extends ZodType {
+var ZodDiscriminatedUnion = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.object) {
@@ -2576,7 +2762,9 @@ var ZodDiscriminatedUnion = class extends ZodType {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
         options: Array.from(this.optionsMap.keys()),
-        path: [discriminator]
+        path: [
+          discriminator
+        ]
       });
       return INVALID;
     }
@@ -2604,13 +2792,13 @@ var ZodDiscriminatedUnion = class extends ZodType {
     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
-   */
+  * 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) {
@@ -2633,28 +2821,41 @@ var ZodDiscriminatedUnion = class extends ZodType {
       ...processCreateParams(params)
     });
   }
-};
-__name(ZodDiscriminatedUnion, "ZodDiscriminatedUnion");
+}, "ZodDiscriminatedUnion");
+__name2(ZodDiscriminatedUnion, "ZodDiscriminatedUnion");
 function mergeValues(a, b) {
   const aType = getParsedType(a);
   const bType = getParsedType(b);
   if (a === b) {
-    return { valid: true, data: a };
+    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 };
+    const newObj = {
+      ...a,
+      ...b
+    };
     for (const key of sharedKeys) {
       const sharedValue = mergeValues(a[key], b[key]);
       if (!sharedValue.valid) {
-        return { valid: false };
+        return {
+          valid: false
+        };
       }
       newObj[key] = sharedValue.data;
     }
-    return { valid: true, data: newObj };
+    return {
+      valid: true,
+      data: newObj
+    };
   } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
     if (a.length !== b.length) {
-      return { valid: false };
+      return {
+        valid: false
+      };
     }
     const newArray = [];
     for (let index = 0; index < a.length; index++) {
@@ -2662,22 +2863,33 @@ function mergeValues(a, b) {
       const itemB = b[index];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
-        return { valid: false };
+        return {
+          valid: false
+        };
       }
       newArray.push(sharedValue.data);
     }
-    return { valid: true, data: newArray };
+    return {
+      valid: true,
+      data: newArray
+    };
   } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
-    return { valid: true, data: a };
+    return {
+      valid: true,
+      data: a
+    };
   } else {
-    return { valid: false };
+    return {
+      valid: false
+    };
   }
 }
 __name(mergeValues, "mergeValues");
-var ZodIntersection = class extends ZodType {
+__name2(mergeValues, "mergeValues");
+var ZodIntersection = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
-    const handleParsed = /* @__PURE__ */ __name((parsedLeft, parsedRight) => {
+    const handleParsed = /* @__PURE__ */ __name2((parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
       }
@@ -2691,7 +2903,10 @@ var ZodIntersection = class extends ZodType {
       if (isDirty(parsedLeft) || isDirty(parsedRight)) {
         status.dirty();
       }
-      return { status: status.value, value: merged.data };
+      return {
+        status: status.value,
+        value: merged.data
+      };
     }, "handleParsed");
     if (ctx.common.async) {
       return Promise.all([
@@ -2718,8 +2933,8 @@ var ZodIntersection = class extends ZodType {
       }));
     }
   }
-};
-__name(ZodIntersection, "ZodIntersection");
+}, "ZodIntersection");
+__name2(ZodIntersection, "ZodIntersection");
 ZodIntersection.create = (left, right, params) => {
   return new ZodIntersection({
     left,
@@ -2728,7 +2943,7 @@ ZodIntersection.create = (left, right, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodTuple = class extends ZodType {
+var ZodTuple = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.array) {
@@ -2760,7 +2975,9 @@ var ZodTuple = class extends ZodType {
       });
       status.dirty();
     }
-    const items = [...ctx.data].map((item, itemIndex) => {
+    const items = [
+      ...ctx.data
+    ].map((item, itemIndex) => {
       const schema = this._def.items[itemIndex] || this._def.rest;
       if (!schema)
         return null;
@@ -2783,8 +3000,8 @@ var ZodTuple = class extends ZodType {
       rest
     });
   }
-};
-__name(ZodTuple, "ZodTuple");
+}, "ZodTuple");
+__name2(ZodTuple, "ZodTuple");
 ZodTuple.create = (schemas, params) => {
   if (!Array.isArray(schemas)) {
     throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
@@ -2796,7 +3013,7 @@ ZodTuple.create = (schemas, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodRecord = class extends ZodType {
+var ZodRecord = /* @__PURE__ */ __name(class extends ZodType {
   get keySchema() {
     return this._def.keyType;
   }
@@ -2847,9 +3064,9 @@ var ZodRecord = class extends ZodType {
       ...processCreateParams(second)
     });
   }
-};
-__name(ZodRecord, "ZodRecord");
-var ZodMap = class extends ZodType {
+}, "ZodRecord");
+__name2(ZodRecord, "ZodRecord");
+var ZodMap = /* @__PURE__ */ __name(class extends ZodType {
   get keySchema() {
     return this._def.keyType;
   }
@@ -2868,10 +3085,18 @@ var ZodMap = class extends ZodType {
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+    const pairs = [
+      ...ctx.data.entries()
+    ].map(([key, value], index) => {
       return {
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [
+          index,
+          "key"
+        ])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [
+          index,
+          "value"
+        ]))
       };
     });
     if (ctx.common.async) {
@@ -2888,7 +3113,10 @@ var ZodMap = class extends ZodType {
           }
           finalMap.set(key.value, value.value);
         }
-        return { status: status.value, value: finalMap };
+        return {
+          status: status.value,
+          value: finalMap
+        };
       });
     } else {
       const finalMap = /* @__PURE__ */ new Map();
@@ -2903,11 +3131,14 @@ var ZodMap = class extends ZodType {
         }
         finalMap.set(key.value, value.value);
       }
-      return { status: status.value, value: finalMap };
+      return {
+        status: status.value,
+        value: finalMap
+      };
     }
   }
-};
-__name(ZodMap, "ZodMap");
+}, "ZodMap");
+__name2(ZodMap, "ZodMap");
 ZodMap.create = (keyType, valueType, params) => {
   return new ZodMap({
     valueType,
@@ -2916,7 +3147,7 @@ ZodMap.create = (keyType, valueType, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodSet = class extends ZodType {
+var ZodSet = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.set) {
@@ -2964,10 +3195,16 @@ var ZodSet = class extends ZodType {
           status.dirty();
         parsedSet.add(element.value);
       }
-      return { status: status.value, value: parsedSet };
+      return {
+        status: status.value,
+        value: parsedSet
+      };
     }
     __name(finalizeSet, "finalizeSet");
-    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+    __name2(finalizeSet, "finalizeSet");
+    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 {
@@ -2977,13 +3214,19 @@ var ZodSet = class extends ZodType {
   min(minSize, message) {
     return new ZodSet({
       ...this._def,
-      minSize: { value: minSize, message: errorUtil.toString(message) }
+      minSize: {
+        value: minSize,
+        message: errorUtil.toString(message)
+      }
     });
   }
   max(maxSize, message) {
     return new ZodSet({
       ...this._def,
-      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+      maxSize: {
+        value: maxSize,
+        message: errorUtil.toString(message)
+      }
     });
   }
   size(size, message) {
@@ -2992,8 +3235,8 @@ var ZodSet = class extends ZodType {
   nonempty(message) {
     return this.min(1, message);
   }
-};
-__name(ZodSet, "ZodSet");
+}, "ZodSet");
+__name2(ZodSet, "ZodSet");
 ZodSet.create = (valueType, params) => {
   return new ZodSet({
     valueType,
@@ -3003,7 +3246,7 @@ ZodSet.create = (valueType, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodFunction = class extends ZodType {
+var ZodFunction = /* @__PURE__ */ __name(class extends ZodType {
   constructor() {
     super(...arguments);
     this.validate = this.implement;
@@ -3035,6 +3278,7 @@ var ZodFunction = class extends ZodType {
       });
     }
     __name(makeArgsIssue, "makeArgsIssue");
+    __name2(makeArgsIssue, "makeArgsIssue");
     function makeReturnsIssue(returns, error) {
       return makeIssue({
         data: returns,
@@ -3052,7 +3296,10 @@ var ZodFunction = class extends ZodType {
       });
     }
     __name(makeReturnsIssue, "makeReturnsIssue");
-    const params = { errorMap: ctx.common.contextualErrorMap };
+    __name2(makeReturnsIssue, "makeReturnsIssue");
+    const params = {
+      errorMap: ctx.common.contextualErrorMap
+    };
     const fn = ctx.data;
     if (this._def.returns instanceof ZodPromise) {
       const me = this;
@@ -3074,12 +3321,16 @@ var ZodFunction = class extends ZodType {
       return OK(function(...args) {
         const parsedArgs = me._def.args.safeParse(args, params);
         if (!parsedArgs.success) {
-          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+          throw new ZodError([
+            makeArgsIssue(args, parsedArgs.error)
+          ]);
         }
         const result = Reflect.apply(fn, this, parsedArgs.data);
         const parsedReturns = me._def.returns.safeParse(result, params);
         if (!parsedReturns.success) {
-          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+          throw new ZodError([
+            makeReturnsIssue(result, parsedReturns.error)
+          ]);
         }
         return parsedReturns.data;
       });
@@ -3119,19 +3370,23 @@ var ZodFunction = class extends ZodType {
       ...processCreateParams(params)
     });
   }
-};
-__name(ZodFunction, "ZodFunction");
-var ZodLazy = class extends ZodType {
+}, "ZodFunction");
+__name2(ZodFunction, "ZodFunction");
+var ZodLazy = /* @__PURE__ */ __name(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 });
+    return lazySchema._parse({
+      data: ctx.data,
+      path: ctx.path,
+      parent: ctx
+    });
   }
-};
-__name(ZodLazy, "ZodLazy");
+}, "ZodLazy");
+__name2(ZodLazy, "ZodLazy");
 ZodLazy.create = (getter, params) => {
   return new ZodLazy({
     getter,
@@ -3139,7 +3394,7 @@ ZodLazy.create = (getter, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodLiteral = class extends ZodType {
+var ZodLiteral = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     if (input.data !== this._def.value) {
       const ctx = this._getOrReturnCtx(input);
@@ -3150,13 +3405,16 @@ var ZodLiteral = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return {
+      status: "valid",
+      value: input.data
+    };
   }
   get value() {
     return this._def.value;
   }
-};
-__name(ZodLiteral, "ZodLiteral");
+}, "ZodLiteral");
+__name2(ZodLiteral, "ZodLiteral");
 ZodLiteral.create = (value, params) => {
   return new ZodLiteral({
     value,
@@ -3172,7 +3430,8 @@ function createZodEnum(values, params) {
   });
 }
 __name(createZodEnum, "createZodEnum");
-var ZodEnum = class extends ZodType {
+__name2(createZodEnum, "createZodEnum");
+var ZodEnum = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     if (typeof input.data !== "string") {
       const ctx = this._getOrReturnCtx(input);
@@ -3226,10 +3485,10 @@ var ZodEnum = class extends ZodType {
   exclude(values) {
     return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)));
   }
-};
-__name(ZodEnum, "ZodEnum");
+}, "ZodEnum");
+__name2(ZodEnum, "ZodEnum");
 ZodEnum.create = createZodEnum;
-var ZodNativeEnum = class extends ZodType {
+var ZodNativeEnum = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
     const ctx = this._getOrReturnCtx(input);
@@ -3256,8 +3515,8 @@ var ZodNativeEnum = class extends ZodType {
   get enum() {
     return this._def.values;
   }
-};
-__name(ZodNativeEnum, "ZodNativeEnum");
+}, "ZodNativeEnum");
+__name2(ZodNativeEnum, "ZodNativeEnum");
 ZodNativeEnum.create = (values, params) => {
   return new ZodNativeEnum({
     values,
@@ -3265,7 +3524,7 @@ ZodNativeEnum.create = (values, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodPromise = class extends ZodType {
+var ZodPromise = /* @__PURE__ */ __name(class extends ZodType {
   unwrap() {
     return this._def.type;
   }
@@ -3287,8 +3546,8 @@ var ZodPromise = class extends ZodType {
       });
     }));
   }
-};
-__name(ZodPromise, "ZodPromise");
+}, "ZodPromise");
+__name2(ZodPromise, "ZodPromise");
 ZodPromise.create = (schema, params) => {
   return new ZodPromise({
     type: schema,
@@ -3296,7 +3555,7 @@ ZodPromise.create = (schema, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodEffects = class extends ZodType {
+var ZodEffects = /* @__PURE__ */ __name(class extends ZodType {
   innerType() {
     return this._def.schema;
   }
@@ -3345,7 +3604,7 @@ var ZodEffects = class extends ZodType {
       }
     }
     if (effect.type === "refinement") {
-      const executeRefinement = /* @__PURE__ */ __name((acc) => {
+      const executeRefinement = /* @__PURE__ */ __name2((acc) => {
         const result = effect.refinement(acc, checkCtx);
         if (ctx.common.async) {
           return Promise.resolve(result);
@@ -3366,15 +3625,25 @@ var ZodEffects = class extends ZodType {
         if (inner.status === "dirty")
           status.dirty();
         executeRefinement(inner.value);
-        return { status: status.value, value: 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) => {
+        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 };
+            return {
+              status: status.value,
+              value: inner.value
+            };
           });
         });
       }
@@ -3392,19 +3661,29 @@ var ZodEffects = class extends ZodType {
         if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
         }
-        return { status: status.value, value: result };
+        return {
+          status: status.value,
+          value: result
+        };
       } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+        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 }));
+          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+            status: status.value,
+            value: result
+          }));
         });
       }
     }
     util.assertNever(effect);
   }
-};
-__name(ZodEffects, "ZodEffects");
+}, "ZodEffects");
+__name2(ZodEffects, "ZodEffects");
 ZodEffects.create = (schema, effect, params) => {
   return new ZodEffects({
     schema,
@@ -3416,12 +3695,15 @@ ZodEffects.create = (schema, effect, params) => {
 ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
   return new ZodEffects({
     schema,
-    effect: { type: "preprocess", transform: preprocess },
+    effect: {
+      type: "preprocess",
+      transform: preprocess
+    },
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params)
   });
 };
-var ZodOptional = class extends ZodType {
+var ZodOptional = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.undefined) {
@@ -3432,8 +3714,8 @@ var ZodOptional = class extends ZodType {
   unwrap() {
     return this._def.innerType;
   }
-};
-__name(ZodOptional, "ZodOptional");
+}, "ZodOptional");
+__name2(ZodOptional, "ZodOptional");
 ZodOptional.create = (type, params) => {
   return new ZodOptional({
     innerType: type,
@@ -3441,7 +3723,7 @@ ZodOptional.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodNullable = class extends ZodType {
+var ZodNullable = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.null) {
@@ -3452,8 +3734,8 @@ var ZodNullable = class extends ZodType {
   unwrap() {
     return this._def.innerType;
   }
-};
-__name(ZodNullable, "ZodNullable");
+}, "ZodNullable");
+__name2(ZodNullable, "ZodNullable");
 ZodNullable.create = (type, params) => {
   return new ZodNullable({
     innerType: type,
@@ -3461,7 +3743,7 @@ ZodNullable.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodDefault = class extends ZodType {
+var ZodDefault = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     let data = ctx.data;
@@ -3477,8 +3759,8 @@ var ZodDefault = class extends ZodType {
   removeDefault() {
     return this._def.innerType;
   }
-};
-__name(ZodDefault, "ZodDefault");
+}, "ZodDefault");
+__name2(ZodDefault, "ZodDefault");
 ZodDefault.create = (type, params) => {
   return new ZodDefault({
     innerType: type,
@@ -3487,7 +3769,7 @@ ZodDefault.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodCatch = class extends ZodType {
+var ZodCatch = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const newCtx = {
@@ -3531,8 +3813,8 @@ var ZodCatch = class extends ZodType {
   removeCatch() {
     return this._def.innerType;
   }
-};
-__name(ZodCatch, "ZodCatch");
+}, "ZodCatch");
+__name2(ZodCatch, "ZodCatch");
 ZodCatch.create = (type, params) => {
   return new ZodCatch({
     innerType: type,
@@ -3541,7 +3823,7 @@ ZodCatch.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodNaN = class extends ZodType {
+var ZodNaN = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.nan) {
@@ -3553,10 +3835,13 @@ var ZodNaN = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return {
+      status: "valid",
+      value: input.data
+    };
   }
-};
-__name(ZodNaN, "ZodNaN");
+}, "ZodNaN");
+__name2(ZodNaN, "ZodNaN");
 ZodNaN.create = (params) => {
   return new ZodNaN({
     typeName: ZodFirstPartyTypeKind.ZodNaN,
@@ -3564,7 +3849,7 @@ ZodNaN.create = (params) => {
   });
 };
 var BRAND = Symbol("zod_brand");
-var ZodBranded = class extends ZodType {
+var ZodBranded = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const data = ctx.data;
@@ -3577,13 +3862,13 @@ var ZodBranded = class extends ZodType {
   unwrap() {
     return this._def.type;
   }
-};
-__name(ZodBranded, "ZodBranded");
-var ZodPipeline = class extends ZodType {
+}, "ZodBranded");
+__name2(ZodBranded, "ZodBranded");
+var ZodPipeline = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.common.async) {
-      const handleAsync = /* @__PURE__ */ __name(async () => {
+      const handleAsync = /* @__PURE__ */ __name2(async () => {
         const inResult = await this._def.in._parseAsync({
           data: ctx.data,
           path: ctx.path,
@@ -3633,9 +3918,9 @@ var ZodPipeline = class extends ZodType {
       typeName: ZodFirstPartyTypeKind.ZodPipeline
     });
   }
-};
-__name(ZodPipeline, "ZodPipeline");
-var ZodReadonly = class extends ZodType {
+}, "ZodPipeline");
+__name2(ZodPipeline, "ZodPipeline");
+var ZodReadonly = /* @__PURE__ */ __name(class extends ZodType {
   _parse(input) {
     const result = this._def.innerType._parse(input);
     if (isValid(result)) {
@@ -3643,8 +3928,8 @@ var ZodReadonly = class extends ZodType {
     }
     return result;
   }
-};
-__name(ZodReadonly, "ZodReadonly");
+}, "ZodReadonly");
+__name2(ZodReadonly, "ZodReadonly");
 ZodReadonly.create = (type, params) => {
   return new ZodReadonly({
     innerType: type,
@@ -3652,15 +3937,23 @@ ZodReadonly.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var custom = /* @__PURE__ */ __name((check, params = {}, fatal) => {
+var custom = /* @__PURE__ */ __name2((check, params = {}, fatal) => {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
       var _a, _b;
       if (!check(data)) {
-        const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+        const p = typeof params === "function" ? params(data) : typeof params === "string" ? {
+          message: params
+        } : params;
         const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-        const p2 = typeof p === "string" ? { message: p } : p;
-        ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
+        const p2 = typeof p === "string" ? {
+          message: p
+        } : p;
+        ctx.addIssue({
+          code: "custom",
+          ...p2,
+          fatal: _fatal
+        });
       }
     });
   return ZodAny.create();
@@ -3707,7 +4000,7 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
   ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = /* @__PURE__ */ __name((cls, params = {
+var instanceOfType = /* @__PURE__ */ __name2((cls, params = {
   message: `Input not instance of ${cls.name}`
 }) => custom((data) => data instanceof cls, params), "instanceOfType");
 var stringType = ZodString.create;
@@ -3744,18 +4037,30 @@ var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
-var ostring = /* @__PURE__ */ __name(() => stringType().optional(), "ostring");
-var onumber = /* @__PURE__ */ __name(() => numberType().optional(), "onumber");
-var oboolean = /* @__PURE__ */ __name(() => booleanType().optional(), "oboolean");
+var ostring = /* @__PURE__ */ __name2(() => stringType().optional(), "ostring");
+var onumber = /* @__PURE__ */ __name2(() => numberType().optional(), "onumber");
+var oboolean = /* @__PURE__ */ __name2(() => booleanType().optional(), "oboolean");
 var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  string: (arg) => ZodString.create({
+    ...arg,
+    coerce: true
+  }),
+  number: (arg) => ZodNumber.create({
+    ...arg,
+    coerce: true
+  }),
   boolean: (arg) => ZodBoolean.create({
     ...arg,
     coerce: true
   }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+  bigint: (arg) => ZodBigInt.create({
+    ...arg,
+    coerce: true
+  }),
+  date: (arg) => ZodDate.create({
+    ...arg,
+    coerce: true
+  })
 };
 var NEVER = INVALID;
 var z = /* @__PURE__ */ Object.freeze({
@@ -3874,11 +4179,11 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
-// ../core/schemas/video-resource.js
+// ../core/dist/schemas/video-resource.js
 var VideoResourceSchema = z.object({
-  _id: z.string(),
-  _updatedAt: z.string().optional(),
-  _createdAt: z.string().optional(),
+  id: z.string(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
   title: z.string().optional().nullable(),
   duration: z.number().optional().nullable(),
   muxPlaybackId: z.string().optional().nullable(),
@@ -3970,9 +4275,9 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
       }
       const query = sql`
     SELECT
-      id as _id,
-      CAST(updatedAt AS DATETIME) as _updatedAt,
-      CAST(createdAt AS DATETIME) as _createdAt,
+      id as id,
+      CAST(updatedAt AS DATETIME) as updatedAt,
+      CAST(createdAt AS DATETIME) as createdAt,
       JSON_EXTRACT (${contentResource.fields}, "$.state") AS state,
       JSON_EXTRACT (${contentResource.fields}, "$.duration") AS duration,
       JSON_EXTRACT (${contentResource.fields}, "$.muxPlaybackId") AS muxPlaybackId,
@@ -4081,6 +4386,8 @@ function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
     async deleteUser(id) {
       const user = await client.select().from(users).where(eq(users.id, id)).then((res) => res[0] ?? null);
       await client.delete(users).where(eq(users.id, id));
+      await client.delete(sessions).where(eq(sessions.userId, id));
+      await client.delete(accounts).where(eq(accounts.userId, id));
       return user;
     },
     async unlinkAccount(account) {
@@ -4096,4 +4403,4 @@ export {
   createTables,
   mySqlDrizzleAdapter
 };
-//# sourceMappingURL=chunk-JQFZOCAU.js.map
+//# sourceMappingURL=chunk-FRNVLW7N.js.map