@coursebuilder/adapter-drizzle 0.0.5 → 0.0.6

package/dist/lib/mysql/index.cjs

@@ -30,18 +30,27 @@ var import_date_fns = require("date-fns");
 var import_drizzle_orm25 = require("drizzle-orm");
 var import_mysql_core30 = require("drizzle-orm/mysql-core");
 
-// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
+// ../core/dist/chunk-DFHEFTJZ.js
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(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 = {};
@@ -84,6 +93,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") {
@@ -98,7 +108,6 @@ var objectUtil;
     return {
       ...first,
       ...second
-      // second overwrites first
     };
   };
 })(objectUtil || (objectUtil = {}));
@@ -124,7 +133,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":
@@ -183,19 +192,25 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
-var quotelessJson = /* @__PURE__ */ __name((obj) => {
+var quotelessJson = /* @__PURE__ */ __name2((obj) => {
   const json8 = JSON.stringify(obj, null, 2);
   return json8.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) {
@@ -213,8 +228,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);
@@ -231,9 +248,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];
@@ -265,18 +286,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:
@@ -372,20 +396,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
@@ -393,7 +424,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,
@@ -412,13 +446,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";
   }
@@ -439,7 +473,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 = [];
@@ -467,25 +504,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;
@@ -503,11 +551,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.");
@@ -532,19 +583,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;
@@ -633,7 +697,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) {
@@ -655,14 +723,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 {
@@ -671,7 +745,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");
@@ -707,7 +781,10 @@ var ZodType = class {
     return new ZodEffects({
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "refinement", refinement }
+      effect: {
+        type: "refinement",
+        refinement
+      }
     });
   }
   superRefine(refinement) {
@@ -729,7 +806,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);
@@ -739,7 +819,10 @@ var ZodType = class {
       ...processCreateParams(this._def),
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "transform", transform }
+      effect: {
+        type: "transform",
+        transform
+      }
     });
   }
   default(def) {
@@ -786,8 +869,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}$/;
@@ -797,7 +880,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)$`);
@@ -828,7 +911,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);
@@ -836,15 +920,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();
@@ -996,7 +1076,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();
@@ -1010,7 +1093,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();
@@ -1020,7 +1105,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();
@@ -1050,7 +1137,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), {
@@ -1062,32 +1152,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;
@@ -1157,28 +1274,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() {
@@ -1228,8 +1360,8 @@ var ZodString = class extends ZodType {
     }
     return max;
   }
-};
-__name(ZodString, "ZodString");
+}, "ZodString");
+__name2(ZodString, "ZodString");
 ZodString.create = (params) => {
   var _a;
   return new ZodString({
@@ -1248,7 +1380,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;
@@ -1334,7 +1467,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));
@@ -1365,7 +1501,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) {
@@ -1470,8 +1609,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: [],
@@ -1480,7 +1619,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;
@@ -1543,7 +1682,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));
@@ -1574,7 +1716,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) {
@@ -1636,8 +1781,8 @@ var ZodBigInt = class extends ZodType {
     }
     return max;
   }
-};
-__name(ZodBigInt, "ZodBigInt");
+}, "ZodBigInt");
+__name2(ZodBigInt, "ZodBigInt");
 ZodBigInt.create = (params) => {
   var _a;
   return new ZodBigInt({
@@ -1647,7 +1792,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);
@@ -1664,8 +1809,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,
@@ -1673,7 +1818,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);
@@ -1736,7 +1881,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) {
@@ -1773,8 +1921,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: [],
@@ -1783,7 +1931,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) {
@@ -1797,15 +1945,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) {
@@ -1819,15 +1967,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) {
@@ -1841,15 +1989,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;
@@ -1857,15 +2005,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;
@@ -1873,15 +2021,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, {
@@ -1891,15 +2039,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) {
@@ -1913,15 +2061,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;
@@ -1976,13 +2124,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);
@@ -1993,26 +2145,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,
@@ -2050,7 +2211,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;
@@ -2062,7 +2224,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);
@@ -2090,7 +2255,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
       });
@@ -2100,8 +2268,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") {
@@ -2122,11 +2296,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
         });
       }
@@ -2212,10 +2386,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,
@@ -2264,7 +2438,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
@@ -2318,8 +2494,8 @@ var ZodObject = class extends ZodType {
     });
   }
   /**
-   * @deprecated
-   */
+  * @deprecated
+  */
   deepPartial() {
     return deepPartialify(this);
   }
@@ -2360,8 +2536,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,
@@ -2389,7 +2565,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;
@@ -2413,6 +2589,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 = {
@@ -2452,7 +2629,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);
@@ -2473,8 +2653,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,
@@ -2482,13 +2662,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) {
@@ -2496,14 +2678,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) {
@@ -2521,7 +2707,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;
     }
@@ -2549,13 +2737,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) {
@@ -2578,28 +2766,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 index16 = 0; index16 < a.length; index16++) {
@@ -2607,22 +2808,33 @@ function mergeValues(a, b) {
       const itemB = b[index16];
       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;
       }
@@ -2636,7 +2848,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([
@@ -2663,8 +2878,8 @@ var ZodIntersection = class extends ZodType {
       }));
     }
   }
-};
-__name(ZodIntersection, "ZodIntersection");
+}, "ZodIntersection");
+__name2(ZodIntersection, "ZodIntersection");
 ZodIntersection.create = (left, right, params) => {
   return new ZodIntersection({
     left,
@@ -2673,7 +2888,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) {
@@ -2705,7 +2920,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;
@@ -2728,8 +2945,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([ ... ])");
@@ -2741,7 +2958,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;
   }
@@ -2792,9 +3009,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;
   }
@@ -2813,10 +3030,18 @@ var ZodMap = class extends ZodType {
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index16) => {
+    const pairs = [
+      ...ctx.data.entries()
+    ].map(([key, value], index16) => {
       return {
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index16, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index16, "value"]))
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [
+          index16,
+          "key"
+        ])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [
+          index16,
+          "value"
+        ]))
       };
     });
     if (ctx.common.async) {
@@ -2833,7 +3058,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();
@@ -2848,11 +3076,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,
@@ -2861,7 +3092,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) {
@@ -2909,10 +3140,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 {
@@ -2922,13 +3159,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) {
@@ -2937,8 +3180,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,
@@ -2948,7 +3191,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;
@@ -2980,6 +3223,7 @@ var ZodFunction = class extends ZodType {
       });
     }
     __name(makeArgsIssue, "makeArgsIssue");
+    __name2(makeArgsIssue, "makeArgsIssue");
     function makeReturnsIssue(returns, error) {
       return makeIssue({
         data: returns,
@@ -2997,7 +3241,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;
@@ -3019,12 +3266,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;
       });
@@ -3064,19 +3315,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,
@@ -3084,7 +3339,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);
@@ -3095,13 +3350,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,
@@ -3117,7 +3375,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);
@@ -3171,10 +3430,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);
@@ -3201,8 +3460,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,
@@ -3210,7 +3469,7 @@ ZodNativeEnum.create = (values, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodPromise = class extends ZodType {
+var ZodPromise = /* @__PURE__ */ __name(class extends ZodType {
   unwrap() {
     return this._def.type;
   }
@@ -3232,8 +3491,8 @@ var ZodPromise = class extends ZodType {
       });
     }));
   }
-};
-__name(ZodPromise, "ZodPromise");
+}, "ZodPromise");
+__name2(ZodPromise, "ZodPromise");
 ZodPromise.create = (schema, params) => {
   return new ZodPromise({
     type: schema,
@@ -3241,7 +3500,7 @@ ZodPromise.create = (schema, params) => {
     ...processCreateParams(params)
   });
 };
-var ZodEffects = class extends ZodType {
+var ZodEffects = /* @__PURE__ */ __name(class extends ZodType {
   innerType() {
     return this._def.schema;
   }
@@ -3290,7 +3549,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);
@@ -3311,15 +3570,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
+            };
           });
         });
       }
@@ -3337,19 +3606,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,
@@ -3361,12 +3640,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) {
@@ -3377,8 +3659,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,
@@ -3386,7 +3668,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) {
@@ -3397,8 +3679,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,
@@ -3406,7 +3688,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;
@@ -3422,8 +3704,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,
@@ -3432,7 +3714,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 = {
@@ -3476,8 +3758,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,
@@ -3486,7 +3768,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) {
@@ -3498,10 +3780,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,
@@ -3509,7 +3794,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;
@@ -3522,13 +3807,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,
@@ -3578,9 +3863,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)) {
@@ -3588,8 +3873,8 @@ var ZodReadonly = class extends ZodType {
     }
     return result;
   }
-};
-__name(ZodReadonly, "ZodReadonly");
+}, "ZodReadonly");
+__name2(ZodReadonly, "ZodReadonly");
 ZodReadonly.create = (type, params) => {
   return new ZodReadonly({
     innerType: type,
@@ -3597,15 +3882,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();
@@ -3652,7 +3945,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;
@@ -3689,18 +3982,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({
@@ -3819,11 +4124,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(),
@@ -4529,7 +4834,8 @@ function getUsersSchema(mysqlTable) {
     }).default(import_drizzle_orm11.sql`CURRENT_TIMESTAMP(3)`)
   }, (user) => ({
     emailIdx: (0, import_mysql_core13.index)("email_idx").on(user.email),
-    roleIdx: (0, import_mysql_core13.index)("role_idx").on(user.role)
+    roleIdx: (0, import_mysql_core13.index)("role_idx").on(user.role),
+    createdAtIdx: (0, import_mysql_core13.index)("created_at_idx").on(user.createdAt)
   }));
 }
 __name(getUsersSchema, "getUsersSchema");
@@ -5042,135 +5348,135 @@ function getProductSchema(mysqlTable) {
 }
 __name(getProductSchema, "getProductSchema");
 
-// src/lib/mysql/schemas/commerce/purchase.ts
+// src/lib/mysql/schemas/commerce/purchase-user-transfer.ts
 var import_drizzle_orm22 = require("drizzle-orm");
 var import_mysql_core27 = require("drizzle-orm/mysql-core");
-function getPurchaseSchema(mysqlTable) {
-  return mysqlTable("purchases", {
+function getPurchaseUserTransferSchema(mysqlTable) {
+  return mysqlTable("purchaseUserTransfers", {
     id: (0, import_mysql_core27.varchar)("id", {
       length: 191
     }).notNull(),
-    userId: (0, import_mysql_core27.varchar)("userId", {
+    transferState: (0, import_mysql_core27.mysqlEnum)("transferState", [
+      "AVAILABLE",
+      "INITIATED",
+      "VERIFIED",
+      "CANCELED",
+      "EXPIRED",
+      "CONFIRMED",
+      "COMPLETED"
+    ]).default("AVAILABLE").notNull(),
+    purchaseId: (0, import_mysql_core27.varchar)("purchaseId", {
+      length: 191
+    }).notNull(),
+    sourceUserId: (0, import_mysql_core27.varchar)("sourceUserId", {
+      length: 191
+    }).notNull(),
+    targetUserId: (0, import_mysql_core27.varchar)("targetUserId", {
       length: 191
     }),
     createdAt: (0, import_mysql_core27.datetime)("createdAt", {
       mode: "string",
       fsp: 3
     }).default(import_drizzle_orm22.sql`CURRENT_TIMESTAMP(3)`).notNull(),
-    totalAmount: (0, import_mysql_core27.decimal)("totalAmount", {
+    expiresAt: (0, import_mysql_core27.datetime)("expiresAt", {
+      mode: "string",
+      fsp: 3
+    }),
+    canceledAt: (0, import_mysql_core27.datetime)("canceledAt", {
+      mode: "string",
+      fsp: 3
+    }),
+    confirmedAt: (0, import_mysql_core27.datetime)("confirmedAt", {
+      mode: "string",
+      fsp: 3
+    }),
+    completedAt: (0, import_mysql_core27.datetime)("completedAt", {
+      mode: "string",
+      fsp: 3
+    })
+  }, (table) => {
+    return {
+      purchaseUserTransferId: (0, import_mysql_core27.primaryKey)({
+        columns: [
+          table.id
+        ],
+        name: "PurchaseUserTransfer_id"
+      })
+    };
+  });
+}
+__name(getPurchaseUserTransferSchema, "getPurchaseUserTransferSchema");
+
+// src/lib/mysql/schemas/commerce/purchase.ts
+var import_drizzle_orm23 = require("drizzle-orm");
+var import_mysql_core28 = require("drizzle-orm/mysql-core");
+function getPurchaseSchema(mysqlTable) {
+  return mysqlTable("purchases", {
+    id: (0, import_mysql_core28.varchar)("id", {
+      length: 191
+    }).notNull(),
+    userId: (0, import_mysql_core28.varchar)("userId", {
+      length: 191
+    }),
+    createdAt: (0, import_mysql_core28.datetime)("createdAt", {
+      mode: "string",
+      fsp: 3
+    }).default(import_drizzle_orm23.sql`CURRENT_TIMESTAMP(3)`).notNull(),
+    totalAmount: (0, import_mysql_core28.decimal)("totalAmount", {
       precision: 65,
       scale: 30
     }).notNull(),
-    ipAddress: (0, import_mysql_core27.varchar)("ip_address", {
+    ipAddress: (0, import_mysql_core28.varchar)("ip_address", {
       length: 191
     }),
-    city: (0, import_mysql_core27.varchar)("city", {
+    city: (0, import_mysql_core28.varchar)("city", {
       length: 191
     }),
-    state: (0, import_mysql_core27.varchar)("state", {
+    state: (0, import_mysql_core28.varchar)("state", {
       length: 191
     }),
-    country: (0, import_mysql_core27.varchar)("country", {
+    country: (0, import_mysql_core28.varchar)("country", {
       length: 191
     }),
-    couponId: (0, import_mysql_core27.varchar)("couponId", {
+    couponId: (0, import_mysql_core28.varchar)("couponId", {
       length: 191
     }),
-    productId: (0, import_mysql_core27.varchar)("productId", {
+    productId: (0, import_mysql_core28.varchar)("productId", {
       length: 191
     }).notNull(),
-    merchantChargeId: (0, import_mysql_core27.varchar)("merchantChargeId", {
+    merchantChargeId: (0, import_mysql_core28.varchar)("merchantChargeId", {
       length: 191
     }),
-    upgradedFromId: (0, import_mysql_core27.varchar)("upgradedFromId", {
+    upgradedFromId: (0, import_mysql_core28.varchar)("upgradedFromId", {
       length: 191
     }),
-    status: (0, import_mysql_core27.varchar)("status", {
+    status: (0, import_mysql_core28.varchar)("status", {
       length: 191
     }).default("Valid").notNull(),
-    bulkCouponId: (0, import_mysql_core27.varchar)("bulkCouponId", {
+    bulkCouponId: (0, import_mysql_core28.varchar)("bulkCouponId", {
       length: 191
     }),
-    merchantSessionId: (0, import_mysql_core27.varchar)("merchantSessionId", {
+    merchantSessionId: (0, import_mysql_core28.varchar)("merchantSessionId", {
       length: 191
     }),
-    redeemedBulkCouponId: (0, import_mysql_core27.varchar)("redeemedBulkCouponId", {
+    redeemedBulkCouponId: (0, import_mysql_core28.varchar)("redeemedBulkCouponId", {
       length: 191
     }),
-    metadata: (0, import_mysql_core27.json)("fields").$type().default({})
+    metadata: (0, import_mysql_core28.json)("fields").$type().default({})
   }, (table) => {
     return {
-      purchaseId: (0, import_mysql_core27.primaryKey)({
+      purchaseId: (0, import_mysql_core28.primaryKey)({
         columns: [
           table.id
         ],
         name: "Purchase_id"
       }),
-      purchaseUpgradedFromIdKey: (0, import_mysql_core27.unique)("Purchase_upgradedFromId_key").on(table.upgradedFromId)
+      purchaseUpgradedFromIdKey: (0, import_mysql_core28.unique)("Purchase_upgradedFromId_key").on(table.upgradedFromId)
     };
   });
 }
 __name(getPurchaseSchema, "getPurchaseSchema");
 
-// src/lib/mysql/schemas/commerce/purchase-user-transfer.ts
-var import_drizzle_orm23 = require("drizzle-orm");
-var import_mysql_core28 = require("drizzle-orm/mysql-core");
-function getPurchaseUserTransferSchema(mysqlTable) {
-  return mysqlTable("purchaseUserTransfers", {
-    id: (0, import_mysql_core28.varchar)("id", {
-      length: 191
-    }).notNull(),
-    transferState: (0, import_mysql_core28.mysqlEnum)("transferState", [
-      "AVAILABLE",
-      "INITIATED",
-      "VERIFIED",
-      "CANCELED",
-      "EXPIRED",
-      "CONFIRMED",
-      "COMPLETED"
-    ]).default("AVAILABLE").notNull(),
-    purchaseId: (0, import_mysql_core28.varchar)("purchaseId", {
-      length: 191
-    }).notNull(),
-    sourceUserId: (0, import_mysql_core28.varchar)("sourceUserId", {
-      length: 191
-    }).notNull(),
-    targetUserId: (0, import_mysql_core28.varchar)("targetUserId", {
-      length: 191
-    }),
-    createdAt: (0, import_mysql_core28.datetime)("createdAt", {
-      mode: "string",
-      fsp: 3
-    }).default(import_drizzle_orm23.sql`CURRENT_TIMESTAMP(3)`).notNull(),
-    expiresAt: (0, import_mysql_core28.datetime)("expiresAt", {
-      mode: "string",
-      fsp: 3
-    }),
-    canceledAt: (0, import_mysql_core28.datetime)("canceledAt", {
-      mode: "string",
-      fsp: 3
-    }),
-    confirmedAt: (0, import_mysql_core28.datetime)("confirmedAt", {
-      mode: "string",
-      fsp: 3
-    }),
-    completedAt: (0, import_mysql_core28.datetime)("completedAt", {
-      mode: "string",
-      fsp: 3
-    })
-  }, (table) => {
-    return {
-      purchaseUserTransferId: (0, import_mysql_core28.primaryKey)({
-        columns: [
-          table.id
-        ],
-        name: "PurchaseUserTransfer_id"
-      })
-    };
-  });
-}
-__name(getPurchaseUserTransferSchema, "getPurchaseUserTransferSchema");
-
 // src/lib/mysql/schemas/content/resource-progress.ts
 var import_drizzle_orm24 = require("drizzle-orm");
 var import_mysql_core29 = require("drizzle-orm/mysql-core");
@@ -5285,9 +5591,9 @@ function mySqlDrizzleAdapter(client, tableFn = import_mysql_core30.mysqlTable) {
       }
       const query = import_drizzle_orm25.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,
@@ -5396,6 +5702,8 @@ function mySqlDrizzleAdapter(client, tableFn = import_mysql_core30.mysqlTable) {
     async deleteUser(id) {
       const user = await client.select().from(users).where((0, import_drizzle_orm25.eq)(users.id, id)).then((res) => res[0] ?? null);
       await client.delete(users).where((0, import_drizzle_orm25.eq)(users.id, id));
+      await client.delete(sessions).where((0, import_drizzle_orm25.eq)(sessions.userId, id));
+      await client.delete(accounts).where((0, import_drizzle_orm25.eq)(accounts.userId, id));
       return user;
     },
     async unlinkAccount(account) {