@learncard/network-plugin 2.1.7 → 2.2.0

package/dist/lcn-plugin.esm.js

@@ -1135,8 +1135,4297 @@ var experimental_formDataLink = httpLinkFactory({
 });
 
 // ../../learn-card-network/brain-client/dist/brain-client.esm.js
+var __create = Object.create;
 var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+var __commonJS = /* @__PURE__ */ __name((cb, mod2) => /* @__PURE__ */ __name(function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+}, "__require"), "__commonJS");
+var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+}, "__copyProps");
+var __toESM = /* @__PURE__ */ __name((mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp2(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+)), "__toESM");
+var require_helpers_cjs_development = __commonJS({
+  "../../learn-card-helpers/dist/helpers.cjs.development.js"(exports, module) {
+    var __create2 = Object.create;
+    var __defProp22 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __name22 = /* @__PURE__ */ __name2((target, value) => __defProp22(target, "name", { value, configurable: true }), "__name");
+    var __commonJS2 = /* @__PURE__ */ __name2((cb, mod2) => /* @__PURE__ */ __name2(/* @__PURE__ */ __name(function __require() {
+      return mod2 || (0, cb[__getOwnPropNames2(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+    }, "__require"), "__require"), "__commonJS");
+    var __export = /* @__PURE__ */ __name2((target, all) => {
+      for (var name in all)
+        __defProp22(target, name, { get: all[name], enumerable: true });
+    }, "__export");
+    var __copyProps2 = /* @__PURE__ */ __name2((to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    }, "__copyProps");
+    var __toESM2 = /* @__PURE__ */ __name2((mod2, isNodeMode, target) => (target = mod2 != null ? __create2(__getProtoOf2(mod2)) : {}, __copyProps2(
+      isNodeMode || !mod2 || !mod2.__esModule ? __defProp22(target, "default", { value: mod2, enumerable: true }) : target,
+      mod2
+    )), "__toESM");
+    var __toCommonJS = /* @__PURE__ */ __name2((mod2) => __copyProps2(__defProp22({}, "__esModule", { value: true }), mod2), "__toCommonJS");
+    var require_types_cjs_development = __commonJS2({
+      "../learn-card-types/dist/types.cjs.development.js"(exports2, module2) {
+        "use strict";
+        var __defProp222 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __name222 = /* @__PURE__ */ __name22((target, value) => __defProp222(target, "name", { value, configurable: true }), "__name");
+        var __export2 = /* @__PURE__ */ __name22((target, all) => {
+          for (var name in all)
+            __defProp222(target, name, { get: all[name], enumerable: true });
+        }, "__export");
+        var __copyProps22 = /* @__PURE__ */ __name22((to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        }, "__copyProps");
+        var __toCommonJS2 = /* @__PURE__ */ __name22((mod22) => __copyProps22(__defProp222({}, "__esModule", { value: true }), mod22), "__toCommonJS");
+        var src_exports2 = {};
+        __export2(src_exports2, {
+          AchievementCredentialValidator: () => AchievementCredentialValidator2,
+          AchievementCriteriaValidator: () => AchievementCriteriaValidator2,
+          AchievementSubjectValidator: () => AchievementSubjectValidator2,
+          AchievementTypeValidator: () => AchievementTypeValidator2,
+          AchievementValidator: () => AchievementValidator2,
+          AddressValidator: () => AddressValidator2,
+          AlignmentTargetTypeValidator: () => AlignmentTargetTypeValidator2,
+          AlignmentValidator: () => AlignmentValidator2,
+          BoostPermissionsValidator: () => BoostPermissionsValidator2,
+          BoostQueryValidator: () => BoostQueryValidator2,
+          BoostRecipientValidator: () => BoostRecipientValidator2,
+          BoostValidator: () => BoostValidator2,
+          ConsentFlowContractDataValidator: () => ConsentFlowContractDataValidator2,
+          ConsentFlowContractDetailsValidator: () => ConsentFlowContractDetailsValidator2,
+          ConsentFlowContractQueryValidator: () => ConsentFlowContractQueryValidator2,
+          ConsentFlowContractValidator: () => ConsentFlowContractValidator2,
+          ConsentFlowDataQueryValidator: () => ConsentFlowDataQueryValidator2,
+          ConsentFlowTermValidator: () => ConsentFlowTermValidator2,
+          ConsentFlowTermsQueryValidator: () => ConsentFlowTermsQueryValidator2,
+          ConsentFlowTermsStatusValidator: () => ConsentFlowTermsStatusValidator2,
+          ConsentFlowTermsValidator: () => ConsentFlowTermsValidator2,
+          ConsentFlowTransactionActionValidator: () => ConsentFlowTransactionActionValidator2,
+          ConsentFlowTransactionValidator: () => ConsentFlowTransactionValidator2,
+          ConsentFlowTransactionsQueryValidator: () => ConsentFlowTransactionsQueryValidator2,
+          ContextValidator: () => ContextValidator2,
+          CredentialInfoValidator: () => CredentialInfoValidator2,
+          CredentialRecordValidator: () => CredentialRecordValidator2,
+          CredentialSchemaValidator: () => CredentialSchemaValidator2,
+          CredentialStatusValidator: () => CredentialStatusValidator2,
+          CredentialSubjectValidator: () => CredentialSubjectValidator2,
+          CriteriaValidator: () => CriteriaValidator2,
+          DidDocumentValidator: () => DidDocumentValidator2,
+          EncryptedCredentialRecordValidator: () => EncryptedCredentialRecordValidator2,
+          EncryptedRecordValidator: () => EncryptedRecordValidator2,
+          EndorsementCredentialValidator: () => EndorsementCredentialValidator2,
+          EndorsementSubjectValidator: () => EndorsementSubjectValidator2,
+          EvidenceValidator: () => EvidenceValidator2,
+          GeoCoordinatesValidator: () => GeoCoordinatesValidator2,
+          IdentifierEntryValidator: () => IdentifierEntryValidator2,
+          IdentifierTypeValidator: () => IdentifierTypeValidator2,
+          IdentityObjectValidator: () => IdentityObjectValidator2,
+          ImageValidator: () => ImageValidator2,
+          JWERecipientHeaderValidator: () => JWERecipientHeaderValidator2,
+          JWERecipientValidator: () => JWERecipientValidator2,
+          JWEValidator: () => JWEValidator2,
+          JWKValidator: () => JWKValidator2,
+          KnownAchievementTypeValidator: () => KnownAchievementTypeValidator2,
+          LCNBoostClaimLinkOptionsValidator: () => LCNBoostClaimLinkOptionsValidator2,
+          LCNBoostClaimLinkSigningAuthorityValidator: () => LCNBoostClaimLinkSigningAuthorityValidator2,
+          LCNBoostStatus: () => LCNBoostStatus2,
+          LCNNotificationDataValidator: () => LCNNotificationDataValidator2,
+          LCNNotificationMessageValidator: () => LCNNotificationMessageValidator2,
+          LCNNotificationTypeEnumValidator: () => LCNNotificationTypeEnumValidator2,
+          LCNNotificationValidator: () => LCNNotificationValidator2,
+          LCNProfileConnectionStatusEnum: () => LCNProfileConnectionStatusEnum2,
+          LCNProfileQueryValidator: () => LCNProfileQueryValidator2,
+          LCNProfileValidator: () => LCNProfileValidator2,
+          LCNSigningAuthorityForUserValidator: () => LCNSigningAuthorityForUserValidator2,
+          LCNSigningAuthorityValidator: () => LCNSigningAuthorityValidator2,
+          PaginatedBoostRecipientsValidator: () => PaginatedBoostRecipientsValidator2,
+          PaginatedBoostsValidator: () => PaginatedBoostsValidator2,
+          PaginatedConsentFlowContractsValidator: () => PaginatedConsentFlowContractsValidator2,
+          PaginatedConsentFlowDataValidator: () => PaginatedConsentFlowDataValidator2,
+          PaginatedConsentFlowTermsValidator: () => PaginatedConsentFlowTermsValidator2,
+          PaginatedConsentFlowTransactionsValidator: () => PaginatedConsentFlowTransactionsValidator2,
+          PaginatedEncryptedCredentialRecordsValidator: () => PaginatedEncryptedCredentialRecordsValidator2,
+          PaginatedEncryptedRecordsValidator: () => PaginatedEncryptedRecordsValidator2,
+          PaginatedLCNProfilesValidator: () => PaginatedLCNProfilesValidator2,
+          PaginationOptionsValidator: () => PaginationOptionsValidator2,
+          PaginationResponseValidator: () => PaginationResponseValidator2,
+          ProfileValidator: () => ProfileValidator2,
+          ProofValidator: () => ProofValidator2,
+          RefreshServiceValidator: () => RefreshServiceValidator2,
+          RelatedValidator: () => RelatedValidator2,
+          ResultDescriptionValidator: () => ResultDescriptionValidator2,
+          ResultStatusTypeValidator: () => ResultStatusTypeValidator2,
+          ResultTypeValidator: () => ResultTypeValidator2,
+          ResultValidator: () => ResultValidator2,
+          RubricCriterionValidator: () => RubricCriterionValidator2,
+          SentCredentialInfoValidator: () => SentCredentialInfoValidator2,
+          ServiceValidator: () => ServiceValidator2,
+          UnsignedAchievementCredentialValidator: () => UnsignedAchievementCredentialValidator2,
+          UnsignedVCValidator: () => UnsignedVCValidator2,
+          UnsignedVPValidator: () => UnsignedVPValidator2,
+          VCValidator: () => VCValidator2,
+          VPValidator: () => VPValidator2,
+          VerificationCheckValidator: () => VerificationCheckValidator2,
+          VerificationItemValidator: () => VerificationItemValidator2,
+          VerificationMethodValidator: () => VerificationMethodValidator2,
+          VerificationStatusEnum: () => VerificationStatusEnum2,
+          VerificationStatusValidator: () => VerificationStatusValidator2
+        });
+        module2.exports = __toCommonJS2(src_exports2);
+        var util2;
+        (function(util22) {
+          util22.assertEqual = (val) => val;
+          function assertIs(_arg) {
+          }
+          __name(assertIs, "assertIs");
+          __name2(assertIs, "assertIs");
+          __name22(assertIs, "assertIs");
+          __name222(assertIs, "assertIs");
+          util22.assertIs = assertIs;
+          function assertNever(_x) {
+            throw new Error();
+          }
+          __name(assertNever, "assertNever");
+          __name2(assertNever, "assertNever");
+          __name22(assertNever, "assertNever");
+          __name222(assertNever, "assertNever");
+          util22.assertNever = assertNever;
+          util22.arrayToEnum = (items) => {
+            const obj = {};
+            for (const item of items) {
+              obj[item] = item;
+            }
+            return obj;
+          };
+          util22.getValidEnumValues = (obj) => {
+            const validKeys = util22.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+            const filtered = {};
+            for (const k of validKeys) {
+              filtered[k] = obj[k];
+            }
+            return util22.objectValues(filtered);
+          };
+          util22.objectValues = (obj) => {
+            return util22.objectKeys(obj).map(function(e) {
+              return obj[e];
+            });
+          };
+          util22.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+            const keys = [];
+            for (const key in object) {
+              if (Object.prototype.hasOwnProperty.call(object, key)) {
+                keys.push(key);
+              }
+            }
+            return keys;
+          };
+          util22.find = (arr, checker) => {
+            for (const item of arr) {
+              if (checker(item))
+                return item;
+            }
+            return void 0;
+          };
+          util22.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+          function joinValues(array, separator = " | ") {
+            return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+          }
+          __name(joinValues, "joinValues");
+          __name2(joinValues, "joinValues");
+          __name22(joinValues, "joinValues");
+          __name222(joinValues, "joinValues");
+          util22.joinValues = joinValues;
+          util22.jsonStringifyReplacer = (_, value) => {
+            if (typeof value === "bigint") {
+              return value.toString();
+            }
+            return value;
+          };
+        })(util2 || (util2 = {}));
+        var ZodParsedType2 = util2.arrayToEnum([
+          "string",
+          "nan",
+          "number",
+          "integer",
+          "float",
+          "boolean",
+          "date",
+          "bigint",
+          "symbol",
+          "function",
+          "undefined",
+          "null",
+          "array",
+          "object",
+          "unknown",
+          "promise",
+          "void",
+          "never",
+          "map",
+          "set"
+        ]);
+        var getParsedType2 = /* @__PURE__ */ __name222((data) => {
+          const t = typeof data;
+          switch (t) {
+            case "undefined":
+              return ZodParsedType2.undefined;
+            case "string":
+              return ZodParsedType2.string;
+            case "number":
+              return isNaN(data) ? ZodParsedType2.nan : ZodParsedType2.number;
+            case "boolean":
+              return ZodParsedType2.boolean;
+            case "function":
+              return ZodParsedType2.function;
+            case "bigint":
+              return ZodParsedType2.bigint;
+            case "symbol":
+              return ZodParsedType2.symbol;
+            case "object":
+              if (Array.isArray(data)) {
+                return ZodParsedType2.array;
+              }
+              if (data === null) {
+                return ZodParsedType2.null;
+              }
+              if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+                return ZodParsedType2.promise;
+              }
+              if (typeof Map !== "undefined" && data instanceof Map) {
+                return ZodParsedType2.map;
+              }
+              if (typeof Set !== "undefined" && data instanceof Set) {
+                return ZodParsedType2.set;
+              }
+              if (typeof Date !== "undefined" && data instanceof Date) {
+                return ZodParsedType2.date;
+              }
+              return ZodParsedType2.object;
+            default:
+              return ZodParsedType2.unknown;
+          }
+        }, "getParsedType");
+        var ZodIssueCode2 = util2.arrayToEnum([
+          "invalid_type",
+          "invalid_literal",
+          "custom",
+          "invalid_union",
+          "invalid_union_discriminator",
+          "invalid_enum_value",
+          "unrecognized_keys",
+          "invalid_arguments",
+          "invalid_return_type",
+          "invalid_date",
+          "invalid_string",
+          "too_small",
+          "too_big",
+          "invalid_intersection_types",
+          "not_multiple_of",
+          "not_finite"
+        ]);
+        var quotelessJson2 = /* @__PURE__ */ __name222((obj) => {
+          const json = JSON.stringify(obj, null, 2);
+          return json.replace(/"([^"]+)":/g, "$1:");
+        }, "quotelessJson");
+        var ZodError2 = /* @__PURE__ */ __name22(class extends Error {
+          constructor(issues) {
+            super();
+            this.issues = [];
+            this.addIssue = (sub) => {
+              this.issues = [...this.issues, sub];
+            };
+            this.addIssues = (subs = []) => {
+              this.issues = [...this.issues, ...subs];
+            };
+            const actualProto = new.target.prototype;
+            if (Object.setPrototypeOf) {
+              Object.setPrototypeOf(this, actualProto);
+            } else {
+              this.__proto__ = actualProto;
+            }
+            this.name = "ZodError";
+            this.issues = issues;
+          }
+          get errors() {
+            return this.issues;
+          }
+          format(_mapper) {
+            const mapper = _mapper || function(issue) {
+              return issue.message;
+            };
+            const fieldErrors = { _errors: [] };
+            const processError = /* @__PURE__ */ __name222((error) => {
+              for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                  issue.unionErrors.map(processError);
+                } else if (issue.code === "invalid_return_type") {
+                  processError(issue.returnTypeError);
+                } else if (issue.code === "invalid_arguments") {
+                  processError(issue.argumentsError);
+                } else if (issue.path.length === 0) {
+                  fieldErrors._errors.push(mapper(issue));
+                } else {
+                  let curr = fieldErrors;
+                  let i = 0;
+                  while (i < issue.path.length) {
+                    const el = issue.path[i];
+                    const terminal = i === issue.path.length - 1;
+                    if (!terminal) {
+                      curr[el] = curr[el] || { _errors: [] };
+                    } else {
+                      curr[el] = curr[el] || { _errors: [] };
+                      curr[el]._errors.push(mapper(issue));
+                    }
+                    curr = curr[el];
+                    i++;
+                  }
+                }
+              }
+            }, "processError");
+            processError(this);
+            return fieldErrors;
+          }
+          toString() {
+            return this.message;
+          }
+          get message() {
+            return JSON.stringify(this.issues, util2.jsonStringifyReplacer, 2);
+          }
+          get isEmpty() {
+            return this.issues.length === 0;
+          }
+          flatten(mapper = (issue) => issue.message) {
+            const fieldErrors = {};
+            const formErrors = [];
+            for (const sub of this.issues) {
+              if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
+              } else {
+                formErrors.push(mapper(sub));
+              }
+            }
+            return { formErrors, fieldErrors };
+          }
+          get formErrors() {
+            return this.flatten();
+          }
+        }, "ZodError");
+        __name222(ZodError2, "ZodError");
+        ZodError2.create = (issues) => {
+          const error = new ZodError2(issues);
+          return error;
+        };
+        var errorMap2 = /* @__PURE__ */ __name222((issue, _ctx) => {
+          let message;
+          switch (issue.code) {
+            case ZodIssueCode2.invalid_type:
+              if (issue.received === ZodParsedType2.undefined) {
+                message = "Required";
+              } else {
+                message = `Expected ${issue.expected}, received ${issue.received}`;
+              }
+              break;
+            case ZodIssueCode2.invalid_literal:
+              message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util2.jsonStringifyReplacer)}`;
+              break;
+            case ZodIssueCode2.unrecognized_keys:
+              message = `Unrecognized key(s) in object: ${util2.joinValues(issue.keys, ", ")}`;
+              break;
+            case ZodIssueCode2.invalid_union:
+              message = `Invalid input`;
+              break;
+            case ZodIssueCode2.invalid_union_discriminator:
+              message = `Invalid discriminator value. Expected ${util2.joinValues(issue.options)}`;
+              break;
+            case ZodIssueCode2.invalid_enum_value:
+              message = `Invalid enum value. Expected ${util2.joinValues(issue.options)}, received '${issue.received}'`;
+              break;
+            case ZodIssueCode2.invalid_arguments:
+              message = `Invalid function arguments`;
+              break;
+            case ZodIssueCode2.invalid_return_type:
+              message = `Invalid function return type`;
+              break;
+            case ZodIssueCode2.invalid_date:
+              message = `Invalid date`;
+              break;
+            case ZodIssueCode2.invalid_string:
+              if (typeof issue.validation === "object") {
+                if ("startsWith" in issue.validation) {
+                  message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+                } else if ("endsWith" in issue.validation) {
+                  message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+                } else {
+                  util2.assertNever(issue.validation);
+                }
+              } else if (issue.validation !== "regex") {
+                message = `Invalid ${issue.validation}`;
+              } else {
+                message = "Invalid";
+              }
+              break;
+            case ZodIssueCode2.too_small:
+              if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+              else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+              else if (issue.type === "number")
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+              else if (issue.type === "date")
+                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(issue.minimum)}`;
+              else
+                message = "Invalid input";
+              break;
+            case ZodIssueCode2.too_big:
+              if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+              else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+              else if (issue.type === "number")
+                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+              else if (issue.type === "date")
+                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(issue.maximum)}`;
+              else
+                message = "Invalid input";
+              break;
+            case ZodIssueCode2.custom:
+              message = `Invalid input`;
+              break;
+            case ZodIssueCode2.invalid_intersection_types:
+              message = `Intersection results could not be merged`;
+              break;
+            case ZodIssueCode2.not_multiple_of:
+              message = `Number must be a multiple of ${issue.multipleOf}`;
+              break;
+            case ZodIssueCode2.not_finite:
+              message = "Number must be finite";
+              break;
+            default:
+              message = _ctx.defaultError;
+              util2.assertNever(issue);
+          }
+          return { message };
+        }, "errorMap");
+        var overrideErrorMap2 = errorMap2;
+        function setErrorMap2(map) {
+          overrideErrorMap2 = map;
+        }
+        __name(setErrorMap2, "setErrorMap");
+        __name2(setErrorMap2, "setErrorMap");
+        __name22(setErrorMap2, "setErrorMap");
+        __name222(setErrorMap2, "setErrorMap");
+        function getErrorMap2() {
+          return overrideErrorMap2;
+        }
+        __name(getErrorMap2, "getErrorMap");
+        __name2(getErrorMap2, "getErrorMap");
+        __name22(getErrorMap2, "getErrorMap");
+        __name222(getErrorMap2, "getErrorMap");
+        var makeIssue2 = /* @__PURE__ */ __name222((params) => {
+          const { data, path, errorMaps, issueData } = params;
+          const fullPath = [...path, ...issueData.path || []];
+          const fullIssue = {
+            ...issueData,
+            path: fullPath
+          };
+          let errorMessage = "";
+          const maps = errorMaps.filter((m) => !!m).slice().reverse();
+          for (const map of maps) {
+            errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+          }
+          return {
+            ...issueData,
+            path: fullPath,
+            message: issueData.message || errorMessage
+          };
+        }, "makeIssue");
+        var EMPTY_PATH2 = [];
+        function addIssueToContext2(ctx, issueData) {
+          const issue = makeIssue2({
+            issueData,
+            data: ctx.data,
+            path: ctx.path,
+            errorMaps: [
+              ctx.common.contextualErrorMap,
+              ctx.schemaErrorMap,
+              getErrorMap2(),
+              errorMap2
+            ].filter((x) => !!x)
+          });
+          ctx.common.issues.push(issue);
+        }
+        __name(addIssueToContext2, "addIssueToContext");
+        __name2(addIssueToContext2, "addIssueToContext");
+        __name22(addIssueToContext2, "addIssueToContext");
+        __name222(addIssueToContext2, "addIssueToContext");
+        var ParseStatus2 = /* @__PURE__ */ __name22(class {
+          constructor() {
+            this.value = "valid";
+          }
+          dirty() {
+            if (this.value === "valid")
+              this.value = "dirty";
+          }
+          abort() {
+            if (this.value !== "aborted")
+              this.value = "aborted";
+          }
+          static mergeArray(status, results) {
+            const arrayValue = [];
+            for (const s of results) {
+              if (s.status === "aborted")
+                return INVALID2;
+              if (s.status === "dirty")
+                status.dirty();
+              arrayValue.push(s.value);
+            }
+            return { status: status.value, value: arrayValue };
+          }
+          static async mergeObjectAsync(status, pairs) {
+            const syncPairs = [];
+            for (const pair of pairs) {
+              syncPairs.push({
+                key: await pair.key,
+                value: await pair.value
+              });
+            }
+            return ParseStatus2.mergeObjectSync(status, syncPairs);
+          }
+          static mergeObjectSync(status, pairs) {
+            const finalObject = {};
+            for (const pair of pairs) {
+              const { key, value } = pair;
+              if (key.status === "aborted")
+                return INVALID2;
+              if (value.status === "aborted")
+                return INVALID2;
+              if (key.status === "dirty")
+                status.dirty();
+              if (value.status === "dirty")
+                status.dirty();
+              if (typeof value.value !== "undefined" || pair.alwaysSet) {
+                finalObject[key.value] = value.value;
+              }
+            }
+            return { status: status.value, value: finalObject };
+          }
+        }, "ParseStatus");
+        __name222(ParseStatus2, "ParseStatus");
+        var INVALID2 = Object.freeze({
+          status: "aborted"
+        });
+        var DIRTY2 = /* @__PURE__ */ __name222((value) => ({ status: "dirty", value }), "DIRTY");
+        var OK2 = /* @__PURE__ */ __name222((value) => ({ status: "valid", value }), "OK");
+        var isAborted2 = /* @__PURE__ */ __name222((x) => x.status === "aborted", "isAborted");
+        var isDirty2 = /* @__PURE__ */ __name222((x) => x.status === "dirty", "isDirty");
+        var isValid2 = /* @__PURE__ */ __name222((x) => x.status === "valid", "isValid");
+        var isAsync2 = /* @__PURE__ */ __name222((x) => typeof Promise !== void 0 && x instanceof Promise, "isAsync");
+        var errorUtil2;
+        (function(errorUtil22) {
+          errorUtil22.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+          errorUtil22.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+        })(errorUtil2 || (errorUtil2 = {}));
+        var ParseInputLazyPath2 = /* @__PURE__ */ __name22(class {
+          constructor(parent, value, path, key) {
+            this.parent = parent;
+            this.data = value;
+            this._path = path;
+            this._key = key;
+          }
+          get path() {
+            return this._path.concat(this._key);
+          }
+        }, "ParseInputLazyPath");
+        __name222(ParseInputLazyPath2, "ParseInputLazyPath");
+        var handleResult2 = /* @__PURE__ */ __name222((ctx, result) => {
+          if (isValid2(result)) {
+            return { success: true, data: result.value };
+          } else {
+            if (!ctx.common.issues.length) {
+              throw new Error("Validation failed but no issues detected.");
+            }
+            const error = new ZodError2(ctx.common.issues);
+            return { success: false, error };
+          }
+        }, "handleResult");
+        function processCreateParams2(params) {
+          if (!params)
+            return {};
+          const { errorMap: errorMap22, invalid_type_error, required_error, description } = params;
+          if (errorMap22 && (invalid_type_error || required_error)) {
+            throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+          }
+          if (errorMap22)
+            return { errorMap: errorMap22, description };
+          const customMap = /* @__PURE__ */ __name222((iss, ctx) => {
+            if (iss.code !== "invalid_type")
+              return { message: ctx.defaultError };
+            if (typeof ctx.data === "undefined") {
+              return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+            }
+            return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
+          }, "customMap");
+          return { errorMap: customMap, description };
+        }
+        __name(processCreateParams2, "processCreateParams");
+        __name2(processCreateParams2, "processCreateParams");
+        __name22(processCreateParams2, "processCreateParams");
+        __name222(processCreateParams2, "processCreateParams");
+        var ZodType2 = /* @__PURE__ */ __name22(class {
+          constructor(def) {
+            this.spa = this.safeParseAsync;
+            this._def = def;
+            this.parse = this.parse.bind(this);
+            this.safeParse = this.safeParse.bind(this);
+            this.parseAsync = this.parseAsync.bind(this);
+            this.safeParseAsync = this.safeParseAsync.bind(this);
+            this.spa = this.spa.bind(this);
+            this.refine = this.refine.bind(this);
+            this.refinement = this.refinement.bind(this);
+            this.superRefine = this.superRefine.bind(this);
+            this.optional = this.optional.bind(this);
+            this.nullable = this.nullable.bind(this);
+            this.nullish = this.nullish.bind(this);
+            this.array = this.array.bind(this);
+            this.promise = this.promise.bind(this);
+            this.or = this.or.bind(this);
+            this.and = this.and.bind(this);
+            this.transform = this.transform.bind(this);
+            this.brand = this.brand.bind(this);
+            this.default = this.default.bind(this);
+            this.catch = this.catch.bind(this);
+            this.describe = this.describe.bind(this);
+            this.pipe = this.pipe.bind(this);
+            this.isNullable = this.isNullable.bind(this);
+            this.isOptional = this.isOptional.bind(this);
+          }
+          get description() {
+            return this._def.description;
+          }
+          _getType(input) {
+            return getParsedType2(input.data);
+          }
+          _getOrReturnCtx(input, ctx) {
+            return ctx || {
+              common: input.parent.common,
+              data: input.data,
+              parsedType: getParsedType2(input.data),
+              schemaErrorMap: this._def.errorMap,
+              path: input.path,
+              parent: input.parent
+            };
+          }
+          _processInputParams(input) {
+            return {
+              status: new ParseStatus2(),
+              ctx: {
+                common: input.parent.common,
+                data: input.data,
+                parsedType: getParsedType2(input.data),
+                schemaErrorMap: this._def.errorMap,
+                path: input.path,
+                parent: input.parent
+              }
+            };
+          }
+          _parseSync(input) {
+            const result = this._parse(input);
+            if (isAsync2(result)) {
+              throw new Error("Synchronous parse encountered promise.");
+            }
+            return result;
+          }
+          _parseAsync(input) {
+            const result = this._parse(input);
+            return Promise.resolve(result);
+          }
+          parse(data, params) {
+            const result = this.safeParse(data, params);
+            if (result.success)
+              return result.data;
+            throw result.error;
+          }
+          safeParse(data, params) {
+            var _a;
+            const ctx = {
+              common: {
+                issues: [],
+                async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
+                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
+              },
+              path: (params === null || params === void 0 ? void 0 : params.path) || [],
+              schemaErrorMap: this._def.errorMap,
+              parent: null,
+              data,
+              parsedType: getParsedType2(data)
+            };
+            const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+            return handleResult2(ctx, result);
+          }
+          async parseAsync(data, params) {
+            const result = await this.safeParseAsync(data, params);
+            if (result.success)
+              return result.data;
+            throw result.error;
+          }
+          async safeParseAsync(data, params) {
+            const ctx = {
+              common: {
+                issues: [],
+                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                async: true
+              },
+              path: (params === null || params === void 0 ? void 0 : params.path) || [],
+              schemaErrorMap: this._def.errorMap,
+              parent: null,
+              data,
+              parsedType: getParsedType2(data)
+            };
+            const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
+            const result = await (isAsync2(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+            return handleResult2(ctx, result);
+          }
+          refine(check, message) {
+            const getIssueProperties = /* @__PURE__ */ __name222((val) => {
+              if (typeof message === "string" || typeof message === "undefined") {
+                return { message };
+              } else if (typeof message === "function") {
+                return message(val);
+              } else {
+                return message;
+              }
+            }, "getIssueProperties");
+            return this._refinement((val, ctx) => {
+              const result = check(val);
+              const setError = /* @__PURE__ */ __name222(() => ctx.addIssue({
+                code: ZodIssueCode2.custom,
+                ...getIssueProperties(val)
+              }), "setError");
+              if (typeof Promise !== "undefined" && result instanceof Promise) {
+                return result.then((data) => {
+                  if (!data) {
+                    setError();
+                    return false;
+                  } else {
+                    return true;
+                  }
+                });
+              }
+              if (!result) {
+                setError();
+                return false;
+              } else {
+                return true;
+              }
+            });
+          }
+          refinement(check, refinementData) {
+            return this._refinement((val, ctx) => {
+              if (!check(val)) {
+                ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+                return false;
+              } else {
+                return true;
+              }
+            });
+          }
+          _refinement(refinement) {
+            return new ZodEffects2({
+              schema: this,
+              typeName: ZodFirstPartyTypeKind2.ZodEffects,
+              effect: { type: "refinement", refinement }
+            });
+          }
+          superRefine(refinement) {
+            return this._refinement(refinement);
+          }
+          optional() {
+            return ZodOptional2.create(this);
+          }
+          nullable() {
+            return ZodNullable2.create(this);
+          }
+          nullish() {
+            return this.optional().nullable();
+          }
+          array() {
+            return ZodArray2.create(this);
+          }
+          promise() {
+            return ZodPromise2.create(this);
+          }
+          or(option) {
+            return ZodUnion2.create([this, option]);
+          }
+          and(incoming) {
+            return ZodIntersection2.create(this, incoming);
+          }
+          transform(transform) {
+            return new ZodEffects2({
+              schema: this,
+              typeName: ZodFirstPartyTypeKind2.ZodEffects,
+              effect: { type: "transform", transform }
+            });
+          }
+          default(def) {
+            const defaultValueFunc = typeof def === "function" ? def : () => def;
+            return new ZodDefault2({
+              innerType: this,
+              defaultValue: defaultValueFunc,
+              typeName: ZodFirstPartyTypeKind2.ZodDefault
+            });
+          }
+          brand() {
+            return new ZodBranded2({
+              typeName: ZodFirstPartyTypeKind2.ZodBranded,
+              type: this,
+              ...processCreateParams2(void 0)
+            });
+          }
+          catch(def) {
+            const defaultValueFunc = typeof def === "function" ? def : () => def;
+            return new ZodCatch2({
+              innerType: this,
+              defaultValue: defaultValueFunc,
+              typeName: ZodFirstPartyTypeKind2.ZodCatch
+            });
+          }
+          describe(description) {
+            const This = this.constructor;
+            return new This({
+              ...this._def,
+              description
+            });
+          }
+          pipe(target) {
+            return ZodPipeline2.create(this, target);
+          }
+          isOptional() {
+            return this.safeParse(void 0).success;
+          }
+          isNullable() {
+            return this.safeParse(null).success;
+          }
+        }, "ZodType");
+        __name222(ZodType2, "ZodType");
+        var cuidRegex2 = /^c[^\s-]{8,}$/i;
+        var uuidRegex2 = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
+        var emailRegex2 = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+        var datetimeRegex2 = /* @__PURE__ */ __name222((args) => {
+          if (args.precision) {
+            if (args.offset) {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}:\\d{2})|Z)$`);
+            } else {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
+            }
+          } else if (args.precision === 0) {
+            if (args.offset) {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}:\\d{2})|Z)$`);
+            } else {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
+            }
+          } else {
+            if (args.offset) {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}:\\d{2})|Z)$`);
+            } else {
+              return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
+            }
+          }
+        }, "datetimeRegex");
+        var ZodString2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), {
+              validation,
+              code: ZodIssueCode2.invalid_string,
+              ...errorUtil2.errToObj(message)
+            });
+            this.nonempty = (message) => this.min(1, errorUtil2.errToObj(message));
+            this.trim = () => new ZodString2({
+              ...this._def,
+              checks: [...this._def.checks, { kind: "trim" }]
+            });
+          }
+          _parse(input) {
+            if (this._def.coerce) {
+              input.data = String(input.data);
+            }
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.string) {
+              const ctx2 = this._getOrReturnCtx(input);
+              addIssueToContext2(
+                ctx2,
+                {
+                  code: ZodIssueCode2.invalid_type,
+                  expected: ZodParsedType2.string,
+                  received: ctx2.parsedType
+                }
+              );
+              return INVALID2;
+            }
+            const status = new ParseStatus2();
+            let ctx = void 0;
+            for (const check of this._def.checks) {
+              if (check.kind === "min") {
+                if (input.data.length < check.value) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_small,
+                    minimum: check.value,
+                    type: "string",
+                    inclusive: true,
+                    exact: false,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "max") {
+                if (input.data.length > check.value) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_big,
+                    maximum: check.value,
+                    type: "string",
+                    inclusive: true,
+                    exact: false,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "length") {
+                const tooBig = input.data.length > check.value;
+                const tooSmall = input.data.length < check.value;
+                if (tooBig || tooSmall) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  if (tooBig) {
+                    addIssueToContext2(ctx, {
+                      code: ZodIssueCode2.too_big,
+                      maximum: check.value,
+                      type: "string",
+                      inclusive: true,
+                      exact: true,
+                      message: check.message
+                    });
+                  } else if (tooSmall) {
+                    addIssueToContext2(ctx, {
+                      code: ZodIssueCode2.too_small,
+                      minimum: check.value,
+                      type: "string",
+                      inclusive: true,
+                      exact: true,
+                      message: check.message
+                    });
+                  }
+                  status.dirty();
+                }
+              } else if (check.kind === "email") {
+                if (!emailRegex2.test(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    validation: "email",
+                    code: ZodIssueCode2.invalid_string,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "uuid") {
+                if (!uuidRegex2.test(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    validation: "uuid",
+                    code: ZodIssueCode2.invalid_string,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "cuid") {
+                if (!cuidRegex2.test(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    validation: "cuid",
+                    code: ZodIssueCode2.invalid_string,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "url") {
+                try {
+                  new URL(input.data);
+                } catch (_a) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    validation: "url",
+                    code: ZodIssueCode2.invalid_string,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "regex") {
+                check.regex.lastIndex = 0;
+                const testResult = check.regex.test(input.data);
+                if (!testResult) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    validation: "regex",
+                    code: ZodIssueCode2.invalid_string,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "trim") {
+                input.data = input.data.trim();
+              } else if (check.kind === "startsWith") {
+                if (!input.data.startsWith(check.value)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.invalid_string,
+                    validation: { startsWith: check.value },
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "endsWith") {
+                if (!input.data.endsWith(check.value)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.invalid_string,
+                    validation: { endsWith: check.value },
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "datetime") {
+                const regex = datetimeRegex2(check);
+                if (!regex.test(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.invalid_string,
+                    validation: "datetime",
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else {
+                util2.assertNever(check);
+              }
+            }
+            return { status: status.value, value: input.data };
+          }
+          _addCheck(check) {
+            return new ZodString2({
+              ...this._def,
+              checks: [...this._def.checks, check]
+            });
+          }
+          email(message) {
+            return this._addCheck({ kind: "email", ...errorUtil2.errToObj(message) });
+          }
+          url(message) {
+            return this._addCheck({ kind: "url", ...errorUtil2.errToObj(message) });
+          }
+          uuid(message) {
+            return this._addCheck({ kind: "uuid", ...errorUtil2.errToObj(message) });
+          }
+          cuid(message) {
+            return this._addCheck({ kind: "cuid", ...errorUtil2.errToObj(message) });
+          }
+          datetime(options) {
+            var _a;
+            if (typeof options === "string") {
+              return this._addCheck({
+                kind: "datetime",
+                precision: null,
+                offset: false,
+                message: options
+              });
+            }
+            return this._addCheck({
+              kind: "datetime",
+              precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
+              offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
+              ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message)
+            });
+          }
+          regex(regex, message) {
+            return this._addCheck({
+              kind: "regex",
+              regex,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          startsWith(value, message) {
+            return this._addCheck({
+              kind: "startsWith",
+              value,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          endsWith(value, message) {
+            return this._addCheck({
+              kind: "endsWith",
+              value,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          min(minLength, message) {
+            return this._addCheck({
+              kind: "min",
+              value: minLength,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          max(maxLength, message) {
+            return this._addCheck({
+              kind: "max",
+              value: maxLength,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          length(len, message) {
+            return this._addCheck({
+              kind: "length",
+              value: len,
+              ...errorUtil2.errToObj(message)
+            });
+          }
+          get isDatetime() {
+            return !!this._def.checks.find((ch) => ch.kind === "datetime");
+          }
+          get isEmail() {
+            return !!this._def.checks.find((ch) => ch.kind === "email");
+          }
+          get isURL() {
+            return !!this._def.checks.find((ch) => ch.kind === "url");
+          }
+          get isUUID() {
+            return !!this._def.checks.find((ch) => ch.kind === "uuid");
+          }
+          get isCUID() {
+            return !!this._def.checks.find((ch) => ch.kind === "cuid");
+          }
+          get minLength() {
+            let min = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                  min = ch.value;
+              }
+            }
+            return min;
+          }
+          get maxLength() {
+            let max = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                  max = ch.value;
+              }
+            }
+            return max;
+          }
+        }, "ZodString");
+        __name222(ZodString2, "ZodString");
+        ZodString2.create = (params) => {
+          var _a;
+          return new ZodString2({
+            checks: [],
+            typeName: ZodFirstPartyTypeKind2.ZodString,
+            coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+            ...processCreateParams2(params)
+          });
+        };
+        function floatSafeRemainder2(val, step) {
+          const valDecCount = (val.toString().split(".")[1] || "").length;
+          const stepDecCount = (step.toString().split(".")[1] || "").length;
+          const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+          const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
+          const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
+          return valInt % stepInt / Math.pow(10, decCount);
+        }
+        __name(floatSafeRemainder2, "floatSafeRemainder");
+        __name2(floatSafeRemainder2, "floatSafeRemainder");
+        __name22(floatSafeRemainder2, "floatSafeRemainder");
+        __name222(floatSafeRemainder2, "floatSafeRemainder");
+        var ZodNumber2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this.min = this.gte;
+            this.max = this.lte;
+            this.step = this.multipleOf;
+          }
+          _parse(input) {
+            if (this._def.coerce) {
+              input.data = Number(input.data);
+            }
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.number) {
+              const ctx2 = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx2, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.number,
+                received: ctx2.parsedType
+              });
+              return INVALID2;
+            }
+            let ctx = void 0;
+            const status = new ParseStatus2();
+            for (const check of this._def.checks) {
+              if (check.kind === "int") {
+                if (!util2.isInteger(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.invalid_type,
+                    expected: "integer",
+                    received: "float",
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "min") {
+                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+                if (tooSmall) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_small,
+                    minimum: check.value,
+                    type: "number",
+                    inclusive: check.inclusive,
+                    exact: false,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "max") {
+                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+                if (tooBig) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_big,
+                    maximum: check.value,
+                    type: "number",
+                    inclusive: check.inclusive,
+                    exact: false,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "multipleOf") {
+                if (floatSafeRemainder2(input.data, check.value) !== 0) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.not_multiple_of,
+                    multipleOf: check.value,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "finite") {
+                if (!Number.isFinite(input.data)) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.not_finite,
+                    message: check.message
+                  });
+                  status.dirty();
+                }
+              } else {
+                util2.assertNever(check);
+              }
+            }
+            return { status: status.value, value: input.data };
+          }
+          gte(value, message) {
+            return this.setLimit("min", value, true, errorUtil2.toString(message));
+          }
+          gt(value, message) {
+            return this.setLimit("min", value, false, errorUtil2.toString(message));
+          }
+          lte(value, message) {
+            return this.setLimit("max", value, true, errorUtil2.toString(message));
+          }
+          lt(value, message) {
+            return this.setLimit("max", value, false, errorUtil2.toString(message));
+          }
+          setLimit(kind, value, inclusive, message) {
+            return new ZodNumber2({
+              ...this._def,
+              checks: [
+                ...this._def.checks,
+                {
+                  kind,
+                  value,
+                  inclusive,
+                  message: errorUtil2.toString(message)
+                }
+              ]
+            });
+          }
+          _addCheck(check) {
+            return new ZodNumber2({
+              ...this._def,
+              checks: [...this._def.checks, check]
+            });
+          }
+          int(message) {
+            return this._addCheck({
+              kind: "int",
+              message: errorUtil2.toString(message)
+            });
+          }
+          positive(message) {
+            return this._addCheck({
+              kind: "min",
+              value: 0,
+              inclusive: false,
+              message: errorUtil2.toString(message)
+            });
+          }
+          negative(message) {
+            return this._addCheck({
+              kind: "max",
+              value: 0,
+              inclusive: false,
+              message: errorUtil2.toString(message)
+            });
+          }
+          nonpositive(message) {
+            return this._addCheck({
+              kind: "max",
+              value: 0,
+              inclusive: true,
+              message: errorUtil2.toString(message)
+            });
+          }
+          nonnegative(message) {
+            return this._addCheck({
+              kind: "min",
+              value: 0,
+              inclusive: true,
+              message: errorUtil2.toString(message)
+            });
+          }
+          multipleOf(value, message) {
+            return this._addCheck({
+              kind: "multipleOf",
+              value,
+              message: errorUtil2.toString(message)
+            });
+          }
+          finite(message) {
+            return this._addCheck({
+              kind: "finite",
+              message: errorUtil2.toString(message)
+            });
+          }
+          get minValue() {
+            let min = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                  min = ch.value;
+              }
+            }
+            return min;
+          }
+          get maxValue() {
+            let max = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                  max = ch.value;
+              }
+            }
+            return max;
+          }
+          get isInt() {
+            return !!this._def.checks.find((ch) => ch.kind === "int");
+          }
+        }, "ZodNumber");
+        __name222(ZodNumber2, "ZodNumber");
+        ZodNumber2.create = (params) => {
+          return new ZodNumber2({
+            checks: [],
+            typeName: ZodFirstPartyTypeKind2.ZodNumber,
+            coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodBigInt2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            if (this._def.coerce) {
+              input.data = BigInt(input.data);
+            }
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.bigint) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.bigint,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodBigInt");
+        __name222(ZodBigInt2, "ZodBigInt");
+        ZodBigInt2.create = (params) => {
+          var _a;
+          return new ZodBigInt2({
+            typeName: ZodFirstPartyTypeKind2.ZodBigInt,
+            coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodBoolean2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            if (this._def.coerce) {
+              input.data = Boolean(input.data);
+            }
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.boolean) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.boolean,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodBoolean");
+        __name222(ZodBoolean2, "ZodBoolean");
+        ZodBoolean2.create = (params) => {
+          return new ZodBoolean2({
+            typeName: ZodFirstPartyTypeKind2.ZodBoolean,
+            coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodDate2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            if (this._def.coerce) {
+              input.data = new Date(input.data);
+            }
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.date) {
+              const ctx2 = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx2, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.date,
+                received: ctx2.parsedType
+              });
+              return INVALID2;
+            }
+            if (isNaN(input.data.getTime())) {
+              const ctx2 = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx2, {
+                code: ZodIssueCode2.invalid_date
+              });
+              return INVALID2;
+            }
+            const status = new ParseStatus2();
+            let ctx = void 0;
+            for (const check of this._def.checks) {
+              if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_small,
+                    message: check.message,
+                    inclusive: true,
+                    exact: false,
+                    minimum: check.value,
+                    type: "date"
+                  });
+                  status.dirty();
+                }
+              } else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                  ctx = this._getOrReturnCtx(input, ctx);
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.too_big,
+                    message: check.message,
+                    inclusive: true,
+                    exact: false,
+                    maximum: check.value,
+                    type: "date"
+                  });
+                  status.dirty();
+                }
+              } else {
+                util2.assertNever(check);
+              }
+            }
+            return {
+              status: status.value,
+              value: new Date(input.data.getTime())
+            };
+          }
+          _addCheck(check) {
+            return new ZodDate2({
+              ...this._def,
+              checks: [...this._def.checks, check]
+            });
+          }
+          min(minDate, message) {
+            return this._addCheck({
+              kind: "min",
+              value: minDate.getTime(),
+              message: errorUtil2.toString(message)
+            });
+          }
+          max(maxDate, message) {
+            return this._addCheck({
+              kind: "max",
+              value: maxDate.getTime(),
+              message: errorUtil2.toString(message)
+            });
+          }
+          get minDate() {
+            let min = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                  min = ch.value;
+              }
+            }
+            return min != null ? new Date(min) : null;
+          }
+          get maxDate() {
+            let max = null;
+            for (const ch of this._def.checks) {
+              if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                  max = ch.value;
+              }
+            }
+            return max != null ? new Date(max) : null;
+          }
+        }, "ZodDate");
+        __name222(ZodDate2, "ZodDate");
+        ZodDate2.create = (params) => {
+          return new ZodDate2({
+            checks: [],
+            coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+            typeName: ZodFirstPartyTypeKind2.ZodDate,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodSymbol2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.symbol) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.symbol,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodSymbol");
+        __name222(ZodSymbol2, "ZodSymbol");
+        ZodSymbol2.create = (params) => {
+          return new ZodSymbol2({
+            typeName: ZodFirstPartyTypeKind2.ZodSymbol,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodUndefined2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.undefined) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.undefined,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodUndefined");
+        __name222(ZodUndefined2, "ZodUndefined");
+        ZodUndefined2.create = (params) => {
+          return new ZodUndefined2({
+            typeName: ZodFirstPartyTypeKind2.ZodUndefined,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodNull2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.null) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.null,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodNull");
+        __name222(ZodNull2, "ZodNull");
+        ZodNull2.create = (params) => {
+          return new ZodNull2({
+            typeName: ZodFirstPartyTypeKind2.ZodNull,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodAny2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this._any = true;
+          }
+          _parse(input) {
+            return OK2(input.data);
+          }
+        }, "ZodAny");
+        __name222(ZodAny2, "ZodAny");
+        ZodAny2.create = (params) => {
+          return new ZodAny2({
+            typeName: ZodFirstPartyTypeKind2.ZodAny,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodUnknown2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this._unknown = true;
+          }
+          _parse(input) {
+            return OK2(input.data);
+          }
+        }, "ZodUnknown");
+        __name222(ZodUnknown2, "ZodUnknown");
+        ZodUnknown2.create = (params) => {
+          return new ZodUnknown2({
+            typeName: ZodFirstPartyTypeKind2.ZodUnknown,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodNever2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const ctx = this._getOrReturnCtx(input);
+            addIssueToContext2(ctx, {
+              code: ZodIssueCode2.invalid_type,
+              expected: ZodParsedType2.never,
+              received: ctx.parsedType
+            });
+            return INVALID2;
+          }
+        }, "ZodNever");
+        __name222(ZodNever2, "ZodNever");
+        ZodNever2.create = (params) => {
+          return new ZodNever2({
+            typeName: ZodFirstPartyTypeKind2.ZodNever,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodVoid2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.undefined) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.void,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+        }, "ZodVoid");
+        __name222(ZodVoid2, "ZodVoid");
+        ZodVoid2.create = (params) => {
+          return new ZodVoid2({
+            typeName: ZodFirstPartyTypeKind2.ZodVoid,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodArray2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx, status } = this._processInputParams(input);
+            const def = this._def;
+            if (ctx.parsedType !== ZodParsedType2.array) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.array,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            if (def.exactLength !== null) {
+              const tooBig = ctx.data.length > def.exactLength.value;
+              const tooSmall = ctx.data.length < def.exactLength.value;
+              if (tooBig || tooSmall) {
+                addIssueToContext2(ctx, {
+                  code: tooBig ? ZodIssueCode2.too_big : ZodIssueCode2.too_small,
+                  minimum: tooSmall ? def.exactLength.value : void 0,
+                  maximum: tooBig ? def.exactLength.value : void 0,
+                  type: "array",
+                  inclusive: true,
+                  exact: true,
+                  message: def.exactLength.message
+                });
+                status.dirty();
+              }
+            }
+            if (def.minLength !== null) {
+              if (ctx.data.length < def.minLength.value) {
+                addIssueToContext2(ctx, {
+                  code: ZodIssueCode2.too_small,
+                  minimum: def.minLength.value,
+                  type: "array",
+                  inclusive: true,
+                  exact: false,
+                  message: def.minLength.message
+                });
+                status.dirty();
+              }
+            }
+            if (def.maxLength !== null) {
+              if (ctx.data.length > def.maxLength.value) {
+                addIssueToContext2(ctx, {
+                  code: ZodIssueCode2.too_big,
+                  maximum: def.maxLength.value,
+                  type: "array",
+                  inclusive: true,
+                  exact: false,
+                  message: def.maxLength.message
+                });
+                status.dirty();
+              }
+            }
+            if (ctx.common.async) {
+              return Promise.all(ctx.data.map((item, i) => {
+                return def.type._parseAsync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
+              })).then((result2) => {
+                return ParseStatus2.mergeArray(status, result2);
+              });
+            }
+            const result = ctx.data.map((item, i) => {
+              return def.type._parseSync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
+            });
+            return ParseStatus2.mergeArray(status, result);
+          }
+          get element() {
+            return this._def.type;
+          }
+          min(minLength, message) {
+            return new ZodArray2({
+              ...this._def,
+              minLength: { value: minLength, message: errorUtil2.toString(message) }
+            });
+          }
+          max(maxLength, message) {
+            return new ZodArray2({
+              ...this._def,
+              maxLength: { value: maxLength, message: errorUtil2.toString(message) }
+            });
+          }
+          length(len, message) {
+            return new ZodArray2({
+              ...this._def,
+              exactLength: { value: len, message: errorUtil2.toString(message) }
+            });
+          }
+          nonempty(message) {
+            return this.min(1, message);
+          }
+        }, "ZodArray");
+        __name222(ZodArray2, "ZodArray");
+        ZodArray2.create = (schema, params) => {
+          return new ZodArray2({
+            type: schema,
+            minLength: null,
+            maxLength: null,
+            exactLength: null,
+            typeName: ZodFirstPartyTypeKind2.ZodArray,
+            ...processCreateParams2(params)
+          });
+        };
+        var objectUtil2;
+        (function(objectUtil22) {
+          objectUtil22.mergeShapes = (first, second) => {
+            return {
+              ...first,
+              ...second
+            };
+          };
+        })(objectUtil2 || (objectUtil2 = {}));
+        var AugmentFactory2 = /* @__PURE__ */ __name222((def) => (augmentation) => {
+          return new ZodObject2({
+            ...def,
+            shape: () => ({
+              ...def.shape(),
+              ...augmentation
+            })
+          });
+        }, "AugmentFactory");
+        function deepPartialify2(schema) {
+          if (schema instanceof ZodObject2) {
+            const newShape = {};
+            for (const key in schema.shape) {
+              const fieldSchema = schema.shape[key];
+              newShape[key] = ZodOptional2.create(deepPartialify2(fieldSchema));
+            }
+            return new ZodObject2({
+              ...schema._def,
+              shape: () => newShape
+            });
+          } else if (schema instanceof ZodArray2) {
+            return ZodArray2.create(deepPartialify2(schema.element));
+          } else if (schema instanceof ZodOptional2) {
+            return ZodOptional2.create(deepPartialify2(schema.unwrap()));
+          } else if (schema instanceof ZodNullable2) {
+            return ZodNullable2.create(deepPartialify2(schema.unwrap()));
+          } else if (schema instanceof ZodTuple2) {
+            return ZodTuple2.create(schema.items.map((item) => deepPartialify2(item)));
+          } else {
+            return schema;
+          }
+        }
+        __name(deepPartialify2, "deepPartialify");
+        __name2(deepPartialify2, "deepPartialify");
+        __name22(deepPartialify2, "deepPartialify");
+        __name222(deepPartialify2, "deepPartialify");
+        var ZodObject2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this._cached = null;
+            this.nonstrict = this.passthrough;
+            this.augment = AugmentFactory2(this._def);
+            this.extend = AugmentFactory2(this._def);
+          }
+          _getCached() {
+            if (this._cached !== null)
+              return this._cached;
+            const shape = this._def.shape();
+            const keys = util2.objectKeys(shape);
+            return this._cached = { shape, keys };
+          }
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.object) {
+              const ctx2 = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx2, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.object,
+                received: ctx2.parsedType
+              });
+              return INVALID2;
+            }
+            const { status, ctx } = this._processInputParams(input);
+            const { shape, keys: shapeKeys } = this._getCached();
+            const extraKeys = [];
+            if (!(this._def.catchall instanceof ZodNever2 && this._def.unknownKeys === "strip")) {
+              for (const key in ctx.data) {
+                if (!shapeKeys.includes(key)) {
+                  extraKeys.push(key);
+                }
+              }
+            }
+            const pairs = [];
+            for (const key of shapeKeys) {
+              const keyValidator = shape[key];
+              const value = ctx.data[key];
+              pairs.push({
+                key: { status: "valid", value: key },
+                value: keyValidator._parse(new ParseInputLazyPath2(ctx, value, ctx.path, key)),
+                alwaysSet: key in ctx.data
+              });
+            }
+            if (this._def.catchall instanceof ZodNever2) {
+              const unknownKeys = this._def.unknownKeys;
+              if (unknownKeys === "passthrough") {
+                for (const key of extraKeys) {
+                  pairs.push({
+                    key: { status: "valid", value: key },
+                    value: { status: "valid", value: ctx.data[key] }
+                  });
+                }
+              } else if (unknownKeys === "strict") {
+                if (extraKeys.length > 0) {
+                  addIssueToContext2(ctx, {
+                    code: ZodIssueCode2.unrecognized_keys,
+                    keys: extraKeys
+                  });
+                  status.dirty();
+                }
+              } else if (unknownKeys === "strip")
+                ;
+              else {
+                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
+              }
+            } else {
+              const catchall = this._def.catchall;
+              for (const key of extraKeys) {
+                const value = ctx.data[key];
+                pairs.push({
+                  key: { status: "valid", value: key },
+                  value: catchall._parse(
+                    new ParseInputLazyPath2(ctx, value, ctx.path, key)
+                  ),
+                  alwaysSet: key in ctx.data
+                });
+              }
+            }
+            if (ctx.common.async) {
+              return Promise.resolve().then(async () => {
+                const syncPairs = [];
+                for (const pair of pairs) {
+                  const key = await pair.key;
+                  syncPairs.push({
+                    key,
+                    value: await pair.value,
+                    alwaysSet: pair.alwaysSet
+                  });
+                }
+                return syncPairs;
+              }).then((syncPairs) => {
+                return ParseStatus2.mergeObjectSync(status, syncPairs);
+              });
+            } else {
+              return ParseStatus2.mergeObjectSync(status, pairs);
+            }
+          }
+          get shape() {
+            return this._def.shape();
+          }
+          strict(message) {
+            errorUtil2.errToObj;
+            return new ZodObject2({
+              ...this._def,
+              unknownKeys: "strict",
+              ...message !== void 0 ? {
+                errorMap: (issue, ctx) => {
+                  var _a, _b, _c, _d;
+                  const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+                  if (issue.code === "unrecognized_keys")
+                    return {
+                      message: (_d = errorUtil2.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
+                    };
+                  return {
+                    message: defaultError
+                  };
+                }
+              } : {}
+            });
+          }
+          strip() {
+            return new ZodObject2({
+              ...this._def,
+              unknownKeys: "strip"
+            });
+          }
+          passthrough() {
+            return new ZodObject2({
+              ...this._def,
+              unknownKeys: "passthrough"
+            });
+          }
+          setKey(key, schema) {
+            return this.augment({ [key]: schema });
+          }
+          merge(merging) {
+            const merged = new ZodObject2({
+              unknownKeys: merging._def.unknownKeys,
+              catchall: merging._def.catchall,
+              shape: () => objectUtil2.mergeShapes(this._def.shape(), merging._def.shape()),
+              typeName: ZodFirstPartyTypeKind2.ZodObject
+            });
+            return merged;
+          }
+          catchall(index) {
+            return new ZodObject2({
+              ...this._def,
+              catchall: index
+            });
+          }
+          pick(mask) {
+            const shape = {};
+            util2.objectKeys(mask).map((key) => {
+              if (this.shape[key])
+                shape[key] = this.shape[key];
+            });
+            return new ZodObject2({
+              ...this._def,
+              shape: () => shape
+            });
+          }
+          omit(mask) {
+            const shape = {};
+            util2.objectKeys(this.shape).map((key) => {
+              if (util2.objectKeys(mask).indexOf(key) === -1) {
+                shape[key] = this.shape[key];
+              }
+            });
+            return new ZodObject2({
+              ...this._def,
+              shape: () => shape
+            });
+          }
+          deepPartial() {
+            return deepPartialify2(this);
+          }
+          partial(mask) {
+            const newShape = {};
+            if (mask) {
+              util2.objectKeys(this.shape).map((key) => {
+                if (util2.objectKeys(mask).indexOf(key) === -1) {
+                  newShape[key] = this.shape[key];
+                } else {
+                  newShape[key] = this.shape[key].optional();
+                }
+              });
+              return new ZodObject2({
+                ...this._def,
+                shape: () => newShape
+              });
+            } else {
+              for (const key in this.shape) {
+                const fieldSchema = this.shape[key];
+                newShape[key] = fieldSchema.optional();
+              }
+            }
+            return new ZodObject2({
+              ...this._def,
+              shape: () => newShape
+            });
+          }
+          required(mask) {
+            const newShape = {};
+            if (mask) {
+              util2.objectKeys(this.shape).map((key) => {
+                if (util2.objectKeys(mask).indexOf(key) === -1) {
+                  newShape[key] = this.shape[key];
+                } else {
+                  const fieldSchema = this.shape[key];
+                  let newField = fieldSchema;
+                  while (newField instanceof ZodOptional2) {
+                    newField = newField._def.innerType;
+                  }
+                  newShape[key] = newField;
+                }
+              });
+            } else {
+              for (const key in this.shape) {
+                const fieldSchema = this.shape[key];
+                let newField = fieldSchema;
+                while (newField instanceof ZodOptional2) {
+                  newField = newField._def.innerType;
+                }
+                newShape[key] = newField;
+              }
+            }
+            return new ZodObject2({
+              ...this._def,
+              shape: () => newShape
+            });
+          }
+          keyof() {
+            return createZodEnum2(util2.objectKeys(this.shape));
+          }
+        }, "ZodObject");
+        __name222(ZodObject2, "ZodObject");
+        ZodObject2.create = (shape, params) => {
+          return new ZodObject2({
+            shape: () => shape,
+            unknownKeys: "strip",
+            catchall: ZodNever2.create(),
+            typeName: ZodFirstPartyTypeKind2.ZodObject,
+            ...processCreateParams2(params)
+          });
+        };
+        ZodObject2.strictCreate = (shape, params) => {
+          return new ZodObject2({
+            shape: () => shape,
+            unknownKeys: "strict",
+            catchall: ZodNever2.create(),
+            typeName: ZodFirstPartyTypeKind2.ZodObject,
+            ...processCreateParams2(params)
+          });
+        };
+        ZodObject2.lazycreate = (shape, params) => {
+          return new ZodObject2({
+            shape,
+            unknownKeys: "strip",
+            catchall: ZodNever2.create(),
+            typeName: ZodFirstPartyTypeKind2.ZodObject,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodUnion2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            const options = this._def.options;
+            function handleResults(results) {
+              for (const result of results) {
+                if (result.result.status === "valid") {
+                  return result.result;
+                }
+              }
+              for (const result of results) {
+                if (result.result.status === "dirty") {
+                  ctx.common.issues.push(...result.ctx.common.issues);
+                  return result.result;
+                }
+              }
+              const unionErrors = results.map((result) => new ZodError2(result.ctx.common.issues));
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_union,
+                unionErrors
+              });
+              return INVALID2;
+            }
+            __name(handleResults, "handleResults");
+            __name2(handleResults, "handleResults");
+            __name22(handleResults, "handleResults");
+            __name222(handleResults, "handleResults");
+            if (ctx.common.async) {
+              return Promise.all(options.map(async (option) => {
+                const childCtx = {
+                  ...ctx,
+                  common: {
+                    ...ctx.common,
+                    issues: []
+                  },
+                  parent: null
+                };
+                return {
+                  result: await option._parseAsync({
+                    data: ctx.data,
+                    path: ctx.path,
+                    parent: childCtx
+                  }),
+                  ctx: childCtx
+                };
+              })).then(handleResults);
+            } else {
+              let dirty = void 0;
+              const issues = [];
+              for (const option of options) {
+                const childCtx = {
+                  ...ctx,
+                  common: {
+                    ...ctx.common,
+                    issues: []
+                  },
+                  parent: null
+                };
+                const result = option._parseSync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: childCtx
+                });
+                if (result.status === "valid") {
+                  return result;
+                } else if (result.status === "dirty" && !dirty) {
+                  dirty = { result, ctx: childCtx };
+                }
+                if (childCtx.common.issues.length) {
+                  issues.push(childCtx.common.issues);
+                }
+              }
+              if (dirty) {
+                ctx.common.issues.push(...dirty.ctx.common.issues);
+                return dirty.result;
+              }
+              const unionErrors = issues.map((issues2) => new ZodError2(issues2));
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_union,
+                unionErrors
+              });
+              return INVALID2;
+            }
+          }
+          get options() {
+            return this._def.options;
+          }
+        }, "ZodUnion");
+        __name222(ZodUnion2, "ZodUnion");
+        ZodUnion2.create = (types, params) => {
+          return new ZodUnion2({
+            options: types,
+            typeName: ZodFirstPartyTypeKind2.ZodUnion,
+            ...processCreateParams2(params)
+          });
+        };
+        var getDiscriminator2 = /* @__PURE__ */ __name222((type) => {
+          if (type instanceof ZodLazy2) {
+            return getDiscriminator2(type.schema);
+          } else if (type instanceof ZodEffects2) {
+            return getDiscriminator2(type.innerType());
+          } else if (type instanceof ZodLiteral2) {
+            return [type.value];
+          } else if (type instanceof ZodEnum2) {
+            return type.options;
+          } else if (type instanceof ZodNativeEnum2) {
+            return Object.keys(type.enum);
+          } else if (type instanceof ZodDefault2) {
+            return getDiscriminator2(type._def.innerType);
+          } else if (type instanceof ZodUndefined2) {
+            return [void 0];
+          } else if (type instanceof ZodNull2) {
+            return [null];
+          } else {
+            return null;
+          }
+        }, "getDiscriminator");
+        var ZodDiscriminatedUnion2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.object) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.object,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            const discriminator = this.discriminator;
+            const discriminatorValue = ctx.data[discriminator];
+            const option = this.optionsMap.get(discriminatorValue);
+            if (!option) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_union_discriminator,
+                options: Array.from(this.optionsMap.keys()),
+                path: [discriminator]
+              });
+              return INVALID2;
+            }
+            if (ctx.common.async) {
+              return option._parseAsync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: ctx
+              });
+            } else {
+              return option._parseSync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: ctx
+              });
+            }
+          }
+          get discriminator() {
+            return this._def.discriminator;
+          }
+          get options() {
+            return this._def.options;
+          }
+          get optionsMap() {
+            return this._def.optionsMap;
+          }
+          static create(discriminator, options, params) {
+            const optionsMap = /* @__PURE__ */ new Map();
+            for (const type of options) {
+              const discriminatorValues = getDiscriminator2(type.shape[discriminator]);
+              if (!discriminatorValues) {
+                throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
+              }
+              for (const value of discriminatorValues) {
+                if (optionsMap.has(value)) {
+                  throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
+                }
+                optionsMap.set(value, type);
+              }
+            }
+            return new ZodDiscriminatedUnion2({
+              typeName: ZodFirstPartyTypeKind2.ZodDiscriminatedUnion,
+              discriminator,
+              options,
+              optionsMap,
+              ...processCreateParams2(params)
+            });
+          }
+        }, "ZodDiscriminatedUnion");
+        __name222(ZodDiscriminatedUnion2, "ZodDiscriminatedUnion");
+        function mergeValues2(a, b) {
+          const aType = getParsedType2(a);
+          const bType = getParsedType2(b);
+          if (a === b) {
+            return { valid: true, data: a };
+          } else if (aType === ZodParsedType2.object && bType === ZodParsedType2.object) {
+            const bKeys = util2.objectKeys(b);
+            const sharedKeys = util2.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+            const newObj = { ...a, ...b };
+            for (const key of sharedKeys) {
+              const sharedValue = mergeValues2(a[key], b[key]);
+              if (!sharedValue.valid) {
+                return { valid: false };
+              }
+              newObj[key] = sharedValue.data;
+            }
+            return { valid: true, data: newObj };
+          } else if (aType === ZodParsedType2.array && bType === ZodParsedType2.array) {
+            if (a.length !== b.length) {
+              return { valid: false };
+            }
+            const newArray = [];
+            for (let index = 0; index < a.length; index++) {
+              const itemA = a[index];
+              const itemB = b[index];
+              const sharedValue = mergeValues2(itemA, itemB);
+              if (!sharedValue.valid) {
+                return { valid: false };
+              }
+              newArray.push(sharedValue.data);
+            }
+            return { valid: true, data: newArray };
+          } else if (aType === ZodParsedType2.date && bType === ZodParsedType2.date && +a === +b) {
+            return { valid: true, data: a };
+          } else {
+            return { valid: false };
+          }
+        }
+        __name(mergeValues2, "mergeValues");
+        __name2(mergeValues2, "mergeValues");
+        __name22(mergeValues2, "mergeValues");
+        __name222(mergeValues2, "mergeValues");
+        var ZodIntersection2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            const handleParsed = /* @__PURE__ */ __name222((parsedLeft, parsedRight) => {
+              if (isAborted2(parsedLeft) || isAborted2(parsedRight)) {
+                return INVALID2;
+              }
+              const merged = mergeValues2(parsedLeft.value, parsedRight.value);
+              if (!merged.valid) {
+                addIssueToContext2(ctx, {
+                  code: ZodIssueCode2.invalid_intersection_types
+                });
+                return INVALID2;
+              }
+              if (isDirty2(parsedLeft) || isDirty2(parsedRight)) {
+                status.dirty();
+              }
+              return { status: status.value, value: merged.data };
+            }, "handleParsed");
+            if (ctx.common.async) {
+              return Promise.all([
+                this._def.left._parseAsync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: ctx
+                }),
+                this._def.right._parseAsync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: ctx
+                })
+              ]).then(([left, right]) => handleParsed(left, right));
+            } else {
+              return handleParsed(this._def.left._parseSync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: ctx
+              }), this._def.right._parseSync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: ctx
+              }));
+            }
+          }
+        }, "ZodIntersection");
+        __name222(ZodIntersection2, "ZodIntersection");
+        ZodIntersection2.create = (left, right, params) => {
+          return new ZodIntersection2({
+            left,
+            right,
+            typeName: ZodFirstPartyTypeKind2.ZodIntersection,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodTuple2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.array) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.array,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            if (ctx.data.length < this._def.items.length) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.too_small,
+                minimum: this._def.items.length,
+                inclusive: true,
+                exact: false,
+                type: "array"
+              });
+              return INVALID2;
+            }
+            const rest = this._def.rest;
+            if (!rest && ctx.data.length > this._def.items.length) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.too_big,
+                maximum: this._def.items.length,
+                inclusive: true,
+                exact: false,
+                type: "array"
+              });
+              status.dirty();
+            }
+            const items = ctx.data.map((item, itemIndex) => {
+              const schema = this._def.items[itemIndex] || this._def.rest;
+              if (!schema)
+                return null;
+              return schema._parse(new ParseInputLazyPath2(ctx, item, ctx.path, itemIndex));
+            }).filter((x) => !!x);
+            if (ctx.common.async) {
+              return Promise.all(items).then((results) => {
+                return ParseStatus2.mergeArray(status, results);
+              });
+            } else {
+              return ParseStatus2.mergeArray(status, items);
+            }
+          }
+          get items() {
+            return this._def.items;
+          }
+          rest(rest) {
+            return new ZodTuple2({
+              ...this._def,
+              rest
+            });
+          }
+        }, "ZodTuple");
+        __name222(ZodTuple2, "ZodTuple");
+        ZodTuple2.create = (schemas, params) => {
+          if (!Array.isArray(schemas)) {
+            throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+          }
+          return new ZodTuple2({
+            items: schemas,
+            typeName: ZodFirstPartyTypeKind2.ZodTuple,
+            rest: null,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodRecord2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          get keySchema() {
+            return this._def.keyType;
+          }
+          get valueSchema() {
+            return this._def.valueType;
+          }
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.object) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.object,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            const pairs = [];
+            const keyType = this._def.keyType;
+            const valueType = this._def.valueType;
+            for (const key in ctx.data) {
+              pairs.push({
+                key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, key)),
+                value: valueType._parse(new ParseInputLazyPath2(ctx, ctx.data[key], ctx.path, key))
+              });
+            }
+            if (ctx.common.async) {
+              return ParseStatus2.mergeObjectAsync(status, pairs);
+            } else {
+              return ParseStatus2.mergeObjectSync(status, pairs);
+            }
+          }
+          get element() {
+            return this._def.valueType;
+          }
+          static create(first, second, third) {
+            if (second instanceof ZodType2) {
+              return new ZodRecord2({
+                keyType: first,
+                valueType: second,
+                typeName: ZodFirstPartyTypeKind2.ZodRecord,
+                ...processCreateParams2(third)
+              });
+            }
+            return new ZodRecord2({
+              keyType: ZodString2.create(),
+              valueType: first,
+              typeName: ZodFirstPartyTypeKind2.ZodRecord,
+              ...processCreateParams2(second)
+            });
+          }
+        }, "ZodRecord");
+        __name222(ZodRecord2, "ZodRecord");
+        var ZodMap2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.map) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.map,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            const keyType = this._def.keyType;
+            const valueType = this._def.valueType;
+            const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+              return {
+                key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, [index, "key"])),
+                value: valueType._parse(new ParseInputLazyPath2(ctx, value, ctx.path, [index, "value"]))
+              };
+            });
+            if (ctx.common.async) {
+              const finalMap = /* @__PURE__ */ new Map();
+              return Promise.resolve().then(async () => {
+                for (const pair of pairs) {
+                  const key = await pair.key;
+                  const value = await pair.value;
+                  if (key.status === "aborted" || value.status === "aborted") {
+                    return INVALID2;
+                  }
+                  if (key.status === "dirty" || value.status === "dirty") {
+                    status.dirty();
+                  }
+                  finalMap.set(key.value, value.value);
+                }
+                return { status: status.value, value: finalMap };
+              });
+            } else {
+              const finalMap = /* @__PURE__ */ new Map();
+              for (const pair of pairs) {
+                const key = pair.key;
+                const value = pair.value;
+                if (key.status === "aborted" || value.status === "aborted") {
+                  return INVALID2;
+                }
+                if (key.status === "dirty" || value.status === "dirty") {
+                  status.dirty();
+                }
+                finalMap.set(key.value, value.value);
+              }
+              return { status: status.value, value: finalMap };
+            }
+          }
+        }, "ZodMap");
+        __name222(ZodMap2, "ZodMap");
+        ZodMap2.create = (keyType, valueType, params) => {
+          return new ZodMap2({
+            valueType,
+            keyType,
+            typeName: ZodFirstPartyTypeKind2.ZodMap,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodSet2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.set) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.set,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            const def = this._def;
+            if (def.minSize !== null) {
+              if (ctx.data.size < def.minSize.value) {
+                addIssueToContext2(ctx, {
+                  code: ZodIssueCode2.too_small,
+                  minimum: def.minSize.value,
+                  type: "set",
+                  inclusive: true,
+                  exact: false,
+                  message: def.minSize.message
+                });
+                status.dirty();
+              }
+            }
+            if (def.maxSize !== null) {
+              if (ctx.data.size > def.maxSize.value) {
+                addIssueToContext2(ctx, {
+                  code: ZodIssueCode2.too_big,
+                  maximum: def.maxSize.value,
+                  type: "set",
+                  inclusive: true,
+                  exact: false,
+                  message: def.maxSize.message
+                });
+                status.dirty();
+              }
+            }
+            const valueType = this._def.valueType;
+            function finalizeSet(elements2) {
+              const parsedSet = /* @__PURE__ */ new Set();
+              for (const element of elements2) {
+                if (element.status === "aborted")
+                  return INVALID2;
+                if (element.status === "dirty")
+                  status.dirty();
+                parsedSet.add(element.value);
+              }
+              return { status: status.value, value: parsedSet };
+            }
+            __name(finalizeSet, "finalizeSet");
+            __name2(finalizeSet, "finalizeSet");
+            __name22(finalizeSet, "finalizeSet");
+            __name222(finalizeSet, "finalizeSet");
+            const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath2(ctx, item, ctx.path, i)));
+            if (ctx.common.async) {
+              return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+            } else {
+              return finalizeSet(elements);
+            }
+          }
+          min(minSize, message) {
+            return new ZodSet2({
+              ...this._def,
+              minSize: { value: minSize, message: errorUtil2.toString(message) }
+            });
+          }
+          max(maxSize, message) {
+            return new ZodSet2({
+              ...this._def,
+              maxSize: { value: maxSize, message: errorUtil2.toString(message) }
+            });
+          }
+          size(size, message) {
+            return this.min(size, message).max(size, message);
+          }
+          nonempty(message) {
+            return this.min(1, message);
+          }
+        }, "ZodSet");
+        __name222(ZodSet2, "ZodSet");
+        ZodSet2.create = (valueType, params) => {
+          return new ZodSet2({
+            valueType,
+            minSize: null,
+            maxSize: null,
+            typeName: ZodFirstPartyTypeKind2.ZodSet,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodFunction2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          constructor() {
+            super(...arguments);
+            this.validate = this.implement;
+          }
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.function) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.function,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            function makeArgsIssue(args, error) {
+              return makeIssue2({
+                data: args,
+                path: ctx.path,
+                errorMaps: [
+                  ctx.common.contextualErrorMap,
+                  ctx.schemaErrorMap,
+                  getErrorMap2(),
+                  errorMap2
+                ].filter((x) => !!x),
+                issueData: {
+                  code: ZodIssueCode2.invalid_arguments,
+                  argumentsError: error
+                }
+              });
+            }
+            __name(makeArgsIssue, "makeArgsIssue");
+            __name2(makeArgsIssue, "makeArgsIssue");
+            __name22(makeArgsIssue, "makeArgsIssue");
+            __name222(makeArgsIssue, "makeArgsIssue");
+            function makeReturnsIssue(returns, error) {
+              return makeIssue2({
+                data: returns,
+                path: ctx.path,
+                errorMaps: [
+                  ctx.common.contextualErrorMap,
+                  ctx.schemaErrorMap,
+                  getErrorMap2(),
+                  errorMap2
+                ].filter((x) => !!x),
+                issueData: {
+                  code: ZodIssueCode2.invalid_return_type,
+                  returnTypeError: error
+                }
+              });
+            }
+            __name(makeReturnsIssue, "makeReturnsIssue");
+            __name2(makeReturnsIssue, "makeReturnsIssue");
+            __name22(makeReturnsIssue, "makeReturnsIssue");
+            __name222(makeReturnsIssue, "makeReturnsIssue");
+            const params = { errorMap: ctx.common.contextualErrorMap };
+            const fn = ctx.data;
+            if (this._def.returns instanceof ZodPromise2) {
+              return OK2(async (...args) => {
+                const error = new ZodError2([]);
+                const parsedArgs = await this._def.args.parseAsync(args, params).catch((e) => {
+                  error.addIssue(makeArgsIssue(args, e));
+                  throw error;
+                });
+                const result = await fn(...parsedArgs);
+                const parsedReturns = await this._def.returns._def.type.parseAsync(result, params).catch((e) => {
+                  error.addIssue(makeReturnsIssue(result, e));
+                  throw error;
+                });
+                return parsedReturns;
+              });
+            } else {
+              return OK2((...args) => {
+                const parsedArgs = this._def.args.safeParse(args, params);
+                if (!parsedArgs.success) {
+                  throw new ZodError2([makeArgsIssue(args, parsedArgs.error)]);
+                }
+                const result = fn(...parsedArgs.data);
+                const parsedReturns = this._def.returns.safeParse(result, params);
+                if (!parsedReturns.success) {
+                  throw new ZodError2([makeReturnsIssue(result, parsedReturns.error)]);
+                }
+                return parsedReturns.data;
+              });
+            }
+          }
+          parameters() {
+            return this._def.args;
+          }
+          returnType() {
+            return this._def.returns;
+          }
+          args(...items) {
+            return new ZodFunction2({
+              ...this._def,
+              args: ZodTuple2.create(items).rest(ZodUnknown2.create())
+            });
+          }
+          returns(returnType) {
+            return new ZodFunction2({
+              ...this._def,
+              returns: returnType
+            });
+          }
+          implement(func) {
+            const validatedFunc = this.parse(func);
+            return validatedFunc;
+          }
+          strictImplement(func) {
+            const validatedFunc = this.parse(func);
+            return validatedFunc;
+          }
+          static create(args, returns, params) {
+            return new ZodFunction2({
+              args: args ? args : ZodTuple2.create([]).rest(ZodUnknown2.create()),
+              returns: returns || ZodUnknown2.create(),
+              typeName: ZodFirstPartyTypeKind2.ZodFunction,
+              ...processCreateParams2(params)
+            });
+          }
+        }, "ZodFunction");
+        __name222(ZodFunction2, "ZodFunction");
+        var ZodLazy2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          get schema() {
+            return this._def.getter();
+          }
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            const lazySchema = this._def.getter();
+            return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+          }
+        }, "ZodLazy");
+        __name222(ZodLazy2, "ZodLazy");
+        ZodLazy2.create = (getter, params) => {
+          return new ZodLazy2({
+            getter,
+            typeName: ZodFirstPartyTypeKind2.ZodLazy,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodLiteral2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            if (input.data !== this._def.value) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_literal,
+                expected: this._def.value
+              });
+              return INVALID2;
+            }
+            return { status: "valid", value: input.data };
+          }
+          get value() {
+            return this._def.value;
+          }
+        }, "ZodLiteral");
+        __name222(ZodLiteral2, "ZodLiteral");
+        ZodLiteral2.create = (value, params) => {
+          return new ZodLiteral2({
+            value,
+            typeName: ZodFirstPartyTypeKind2.ZodLiteral,
+            ...processCreateParams2(params)
+          });
+        };
+        function createZodEnum2(values, params) {
+          return new ZodEnum2({
+            values,
+            typeName: ZodFirstPartyTypeKind2.ZodEnum,
+            ...processCreateParams2(params)
+          });
+        }
+        __name(createZodEnum2, "createZodEnum");
+        __name2(createZodEnum2, "createZodEnum");
+        __name22(createZodEnum2, "createZodEnum");
+        __name222(createZodEnum2, "createZodEnum");
+        var ZodEnum2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            if (typeof input.data !== "string") {
+              const ctx = this._getOrReturnCtx(input);
+              const expectedValues = this._def.values;
+              addIssueToContext2(ctx, {
+                expected: util2.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodIssueCode2.invalid_type
+              });
+              return INVALID2;
+            }
+            if (this._def.values.indexOf(input.data) === -1) {
+              const ctx = this._getOrReturnCtx(input);
+              const expectedValues = this._def.values;
+              addIssueToContext2(ctx, {
+                received: ctx.data,
+                code: ZodIssueCode2.invalid_enum_value,
+                options: expectedValues
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+          get options() {
+            return this._def.values;
+          }
+          get enum() {
+            const enumValues = {};
+            for (const val of this._def.values) {
+              enumValues[val] = val;
+            }
+            return enumValues;
+          }
+          get Values() {
+            const enumValues = {};
+            for (const val of this._def.values) {
+              enumValues[val] = val;
+            }
+            return enumValues;
+          }
+          get Enum() {
+            const enumValues = {};
+            for (const val of this._def.values) {
+              enumValues[val] = val;
+            }
+            return enumValues;
+          }
+        }, "ZodEnum");
+        __name222(ZodEnum2, "ZodEnum");
+        ZodEnum2.create = createZodEnum2;
+        var ZodNativeEnum2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const nativeEnumValues = util2.getValidEnumValues(this._def.values);
+            const ctx = this._getOrReturnCtx(input);
+            if (ctx.parsedType !== ZodParsedType2.string && ctx.parsedType !== ZodParsedType2.number) {
+              const expectedValues = util2.objectValues(nativeEnumValues);
+              addIssueToContext2(ctx, {
+                expected: util2.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodIssueCode2.invalid_type
+              });
+              return INVALID2;
+            }
+            if (nativeEnumValues.indexOf(input.data) === -1) {
+              const expectedValues = util2.objectValues(nativeEnumValues);
+              addIssueToContext2(ctx, {
+                received: ctx.data,
+                code: ZodIssueCode2.invalid_enum_value,
+                options: expectedValues
+              });
+              return INVALID2;
+            }
+            return OK2(input.data);
+          }
+          get enum() {
+            return this._def.values;
+          }
+        }, "ZodNativeEnum");
+        __name222(ZodNativeEnum2, "ZodNativeEnum");
+        ZodNativeEnum2.create = (values, params) => {
+          return new ZodNativeEnum2({
+            values,
+            typeName: ZodFirstPartyTypeKind2.ZodNativeEnum,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodPromise2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            if (ctx.parsedType !== ZodParsedType2.promise && ctx.common.async === false) {
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.promise,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            const promisified = ctx.parsedType === ZodParsedType2.promise ? ctx.data : Promise.resolve(ctx.data);
+            return OK2(promisified.then((data) => {
+              return this._def.type.parseAsync(data, {
+                path: ctx.path,
+                errorMap: ctx.common.contextualErrorMap
+              });
+            }));
+          }
+        }, "ZodPromise");
+        __name222(ZodPromise2, "ZodPromise");
+        ZodPromise2.create = (schema, params) => {
+          return new ZodPromise2({
+            type: schema,
+            typeName: ZodFirstPartyTypeKind2.ZodPromise,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodEffects2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          innerType() {
+            return this._def.schema;
+          }
+          sourceType() {
+            return this._def.schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+          }
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            const effect = this._def.effect || null;
+            if (effect.type === "preprocess") {
+              const processed = effect.transform(ctx.data);
+              if (ctx.common.async) {
+                return Promise.resolve(processed).then((processed2) => {
+                  return this._def.schema._parseAsync({
+                    data: processed2,
+                    path: ctx.path,
+                    parent: ctx
+                  });
+                });
+              } else {
+                return this._def.schema._parseSync({
+                  data: processed,
+                  path: ctx.path,
+                  parent: ctx
+                });
+              }
+            }
+            const checkCtx = {
+              addIssue: (arg) => {
+                addIssueToContext2(ctx, arg);
+                if (arg.fatal) {
+                  status.abort();
+                } else {
+                  status.dirty();
+                }
+              },
+              get path() {
+                return ctx.path;
+              }
+            };
+            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+            if (effect.type === "refinement") {
+              const executeRefinement = /* @__PURE__ */ __name222((acc) => {
+                const result = effect.refinement(acc, checkCtx);
+                if (ctx.common.async) {
+                  return Promise.resolve(result);
+                }
+                if (result instanceof Promise) {
+                  throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+                }
+                return acc;
+              }, "executeRefinement");
+              if (ctx.common.async === false) {
+                const inner = this._def.schema._parseSync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: ctx
+                });
+                if (inner.status === "aborted")
+                  return INVALID2;
+                if (inner.status === "dirty")
+                  status.dirty();
+                executeRefinement(inner.value);
+                return { status: status.value, value: inner.value };
+              } else {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+                  if (inner.status === "aborted")
+                    return INVALID2;
+                  if (inner.status === "dirty")
+                    status.dirty();
+                  return executeRefinement(inner.value).then(() => {
+                    return { status: status.value, value: inner.value };
+                  });
+                });
+              }
+            }
+            if (effect.type === "transform") {
+              if (ctx.common.async === false) {
+                const base = this._def.schema._parseSync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: ctx
+                });
+                if (!isValid2(base))
+                  return base;
+                const result = effect.transform(base.value, checkCtx);
+                if (result instanceof Promise) {
+                  throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+                }
+                return { status: status.value, value: result };
+              } else {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+                  if (!isValid2(base))
+                    return base;
+                  return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+                });
+              }
+            }
+            util2.assertNever(effect);
+          }
+        }, "ZodEffects");
+        __name222(ZodEffects2, "ZodEffects");
+        ZodEffects2.create = (schema, effect, params) => {
+          return new ZodEffects2({
+            schema,
+            typeName: ZodFirstPartyTypeKind2.ZodEffects,
+            effect,
+            ...processCreateParams2(params)
+          });
+        };
+        ZodEffects2.createWithPreprocess = (preprocess, schema, params) => {
+          return new ZodEffects2({
+            schema,
+            effect: { type: "preprocess", transform: preprocess },
+            typeName: ZodFirstPartyTypeKind2.ZodEffects,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodOptional2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType === ZodParsedType2.undefined) {
+              return OK2(void 0);
+            }
+            return this._def.innerType._parse(input);
+          }
+          unwrap() {
+            return this._def.innerType;
+          }
+        }, "ZodOptional");
+        __name222(ZodOptional2, "ZodOptional");
+        ZodOptional2.create = (type, params) => {
+          return new ZodOptional2({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind2.ZodOptional,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodNullable2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType === ZodParsedType2.null) {
+              return OK2(null);
+            }
+            return this._def.innerType._parse(input);
+          }
+          unwrap() {
+            return this._def.innerType;
+          }
+        }, "ZodNullable");
+        __name222(ZodNullable2, "ZodNullable");
+        ZodNullable2.create = (type, params) => {
+          return new ZodNullable2({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind2.ZodNullable,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodDefault2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            let data = ctx.data;
+            if (ctx.parsedType === ZodParsedType2.undefined) {
+              data = this._def.defaultValue();
+            }
+            return this._def.innerType._parse({
+              data,
+              path: ctx.path,
+              parent: ctx
+            });
+          }
+          removeDefault() {
+            return this._def.innerType;
+          }
+        }, "ZodDefault");
+        __name222(ZodDefault2, "ZodDefault");
+        ZodDefault2.create = (type, params) => {
+          return new ZodDefault2({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind2.ZodDefault,
+            defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodCatch2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            const result = this._def.innerType._parse({
+              data: ctx.data,
+              path: ctx.path,
+              parent: ctx
+            });
+            if (isAsync2(result)) {
+              return result.then((result2) => {
+                return {
+                  status: "valid",
+                  value: result2.status === "valid" ? result2.value : this._def.defaultValue()
+                };
+              });
+            } else {
+              return {
+                status: "valid",
+                value: result.status === "valid" ? result.value : this._def.defaultValue()
+              };
+            }
+          }
+          removeDefault() {
+            return this._def.innerType;
+          }
+        }, "ZodCatch");
+        __name222(ZodCatch2, "ZodCatch");
+        ZodCatch2.create = (type, params) => {
+          return new ZodCatch2({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind2.ZodCatch,
+            defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+            ...processCreateParams2(params)
+          });
+        };
+        var ZodNaN2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const parsedType = this._getType(input);
+            if (parsedType !== ZodParsedType2.nan) {
+              const ctx = this._getOrReturnCtx(input);
+              addIssueToContext2(ctx, {
+                code: ZodIssueCode2.invalid_type,
+                expected: ZodParsedType2.nan,
+                received: ctx.parsedType
+              });
+              return INVALID2;
+            }
+            return { status: "valid", value: input.data };
+          }
+        }, "ZodNaN");
+        __name222(ZodNaN2, "ZodNaN");
+        ZodNaN2.create = (params) => {
+          return new ZodNaN2({
+            typeName: ZodFirstPartyTypeKind2.ZodNaN,
+            ...processCreateParams2(params)
+          });
+        };
+        var BRAND2 = Symbol("zod_brand");
+        var ZodBranded2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { ctx } = this._processInputParams(input);
+            const data = ctx.data;
+            return this._def.type._parse({
+              data,
+              path: ctx.path,
+              parent: ctx
+            });
+          }
+          unwrap() {
+            return this._def.type;
+          }
+        }, "ZodBranded");
+        __name222(ZodBranded2, "ZodBranded");
+        var ZodPipeline2 = /* @__PURE__ */ __name22(class extends ZodType2 {
+          _parse(input) {
+            const { status, ctx } = this._processInputParams(input);
+            if (ctx.common.async) {
+              const handleAsync = /* @__PURE__ */ __name222(async () => {
+                const inResult = await this._def.in._parseAsync({
+                  data: ctx.data,
+                  path: ctx.path,
+                  parent: ctx
+                });
+                if (inResult.status === "aborted")
+                  return INVALID2;
+                if (inResult.status === "dirty") {
+                  status.dirty();
+                  return DIRTY2(inResult.value);
+                } else {
+                  return this._def.out._parseAsync({
+                    data: inResult.value,
+                    path: ctx.path,
+                    parent: ctx
+                  });
+                }
+              }, "handleAsync");
+              return handleAsync();
+            } else {
+              const inResult = this._def.in._parseSync({
+                data: ctx.data,
+                path: ctx.path,
+                parent: ctx
+              });
+              if (inResult.status === "aborted")
+                return INVALID2;
+              if (inResult.status === "dirty") {
+                status.dirty();
+                return {
+                  status: "dirty",
+                  value: inResult.value
+                };
+              } else {
+                return this._def.out._parseSync({
+                  data: inResult.value,
+                  path: ctx.path,
+                  parent: ctx
+                });
+              }
+            }
+          }
+          static create(a, b) {
+            return new ZodPipeline2({
+              in: a,
+              out: b,
+              typeName: ZodFirstPartyTypeKind2.ZodPipeline
+            });
+          }
+        }, "ZodPipeline");
+        __name222(ZodPipeline2, "ZodPipeline");
+        var custom2 = /* @__PURE__ */ __name222((check, params = {}, fatal) => {
+          if (check)
+            return ZodAny2.create().superRefine((data, ctx) => {
+              if (!check(data)) {
+                const p = typeof params === "function" ? params(data) : params;
+                const p2 = typeof p === "string" ? { message: p } : p;
+                ctx.addIssue({ code: "custom", ...p2, fatal });
+              }
+            });
+          return ZodAny2.create();
+        }, "custom");
+        var late2 = {
+          object: ZodObject2.lazycreate
+        };
+        var ZodFirstPartyTypeKind2;
+        (function(ZodFirstPartyTypeKind22) {
+          ZodFirstPartyTypeKind22["ZodString"] = "ZodString";
+          ZodFirstPartyTypeKind22["ZodNumber"] = "ZodNumber";
+          ZodFirstPartyTypeKind22["ZodNaN"] = "ZodNaN";
+          ZodFirstPartyTypeKind22["ZodBigInt"] = "ZodBigInt";
+          ZodFirstPartyTypeKind22["ZodBoolean"] = "ZodBoolean";
+          ZodFirstPartyTypeKind22["ZodDate"] = "ZodDate";
+          ZodFirstPartyTypeKind22["ZodSymbol"] = "ZodSymbol";
+          ZodFirstPartyTypeKind22["ZodUndefined"] = "ZodUndefined";
+          ZodFirstPartyTypeKind22["ZodNull"] = "ZodNull";
+          ZodFirstPartyTypeKind22["ZodAny"] = "ZodAny";
+          ZodFirstPartyTypeKind22["ZodUnknown"] = "ZodUnknown";
+          ZodFirstPartyTypeKind22["ZodNever"] = "ZodNever";
+          ZodFirstPartyTypeKind22["ZodVoid"] = "ZodVoid";
+          ZodFirstPartyTypeKind22["ZodArray"] = "ZodArray";
+          ZodFirstPartyTypeKind22["ZodObject"] = "ZodObject";
+          ZodFirstPartyTypeKind22["ZodUnion"] = "ZodUnion";
+          ZodFirstPartyTypeKind22["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+          ZodFirstPartyTypeKind22["ZodIntersection"] = "ZodIntersection";
+          ZodFirstPartyTypeKind22["ZodTuple"] = "ZodTuple";
+          ZodFirstPartyTypeKind22["ZodRecord"] = "ZodRecord";
+          ZodFirstPartyTypeKind22["ZodMap"] = "ZodMap";
+          ZodFirstPartyTypeKind22["ZodSet"] = "ZodSet";
+          ZodFirstPartyTypeKind22["ZodFunction"] = "ZodFunction";
+          ZodFirstPartyTypeKind22["ZodLazy"] = "ZodLazy";
+          ZodFirstPartyTypeKind22["ZodLiteral"] = "ZodLiteral";
+          ZodFirstPartyTypeKind22["ZodEnum"] = "ZodEnum";
+          ZodFirstPartyTypeKind22["ZodEffects"] = "ZodEffects";
+          ZodFirstPartyTypeKind22["ZodNativeEnum"] = "ZodNativeEnum";
+          ZodFirstPartyTypeKind22["ZodOptional"] = "ZodOptional";
+          ZodFirstPartyTypeKind22["ZodNullable"] = "ZodNullable";
+          ZodFirstPartyTypeKind22["ZodDefault"] = "ZodDefault";
+          ZodFirstPartyTypeKind22["ZodCatch"] = "ZodCatch";
+          ZodFirstPartyTypeKind22["ZodPromise"] = "ZodPromise";
+          ZodFirstPartyTypeKind22["ZodBranded"] = "ZodBranded";
+          ZodFirstPartyTypeKind22["ZodPipeline"] = "ZodPipeline";
+        })(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
+        var instanceOfType2 = /* @__PURE__ */ __name222((cls, params = {
+          message: `Input not instance of ${cls.name}`
+        }) => custom2((data) => data instanceof cls, params, true), "instanceOfType");
+        var stringType2 = ZodString2.create;
+        var numberType2 = ZodNumber2.create;
+        var nanType2 = ZodNaN2.create;
+        var bigIntType2 = ZodBigInt2.create;
+        var booleanType2 = ZodBoolean2.create;
+        var dateType2 = ZodDate2.create;
+        var symbolType2 = ZodSymbol2.create;
+        var undefinedType2 = ZodUndefined2.create;
+        var nullType2 = ZodNull2.create;
+        var anyType2 = ZodAny2.create;
+        var unknownType2 = ZodUnknown2.create;
+        var neverType2 = ZodNever2.create;
+        var voidType2 = ZodVoid2.create;
+        var arrayType2 = ZodArray2.create;
+        var objectType2 = ZodObject2.create;
+        var strictObjectType2 = ZodObject2.strictCreate;
+        var unionType2 = ZodUnion2.create;
+        var discriminatedUnionType2 = ZodDiscriminatedUnion2.create;
+        var intersectionType2 = ZodIntersection2.create;
+        var tupleType2 = ZodTuple2.create;
+        var recordType2 = ZodRecord2.create;
+        var mapType2 = ZodMap2.create;
+        var setType2 = ZodSet2.create;
+        var functionType2 = ZodFunction2.create;
+        var lazyType2 = ZodLazy2.create;
+        var literalType2 = ZodLiteral2.create;
+        var enumType2 = ZodEnum2.create;
+        var nativeEnumType2 = ZodNativeEnum2.create;
+        var promiseType2 = ZodPromise2.create;
+        var effectsType2 = ZodEffects2.create;
+        var optionalType2 = ZodOptional2.create;
+        var nullableType2 = ZodNullable2.create;
+        var preprocessType2 = ZodEffects2.createWithPreprocess;
+        var pipelineType2 = ZodPipeline2.create;
+        var ostring2 = /* @__PURE__ */ __name222(() => stringType2().optional(), "ostring");
+        var onumber2 = /* @__PURE__ */ __name222(() => numberType2().optional(), "onumber");
+        var oboolean2 = /* @__PURE__ */ __name222(() => booleanType2().optional(), "oboolean");
+        var coerce2 = {
+          string: (arg) => ZodString2.create({ ...arg, coerce: true }),
+          number: (arg) => ZodNumber2.create({ ...arg, coerce: true }),
+          boolean: (arg) => ZodBoolean2.create({ ...arg, coerce: true }),
+          bigint: (arg) => ZodBigInt2.create({ ...arg, coerce: true }),
+          date: (arg) => ZodDate2.create({ ...arg, coerce: true })
+        };
+        var NEVER2 = INVALID2;
+        var mod2 = /* @__PURE__ */ Object.freeze({
+          __proto__: null,
+          defaultErrorMap: errorMap2,
+          setErrorMap: setErrorMap2,
+          getErrorMap: getErrorMap2,
+          makeIssue: makeIssue2,
+          EMPTY_PATH: EMPTY_PATH2,
+          addIssueToContext: addIssueToContext2,
+          ParseStatus: ParseStatus2,
+          INVALID: INVALID2,
+          DIRTY: DIRTY2,
+          OK: OK2,
+          isAborted: isAborted2,
+          isDirty: isDirty2,
+          isValid: isValid2,
+          isAsync: isAsync2,
+          get util() {
+            return util2;
+          },
+          ZodParsedType: ZodParsedType2,
+          getParsedType: getParsedType2,
+          ZodType: ZodType2,
+          ZodString: ZodString2,
+          ZodNumber: ZodNumber2,
+          ZodBigInt: ZodBigInt2,
+          ZodBoolean: ZodBoolean2,
+          ZodDate: ZodDate2,
+          ZodSymbol: ZodSymbol2,
+          ZodUndefined: ZodUndefined2,
+          ZodNull: ZodNull2,
+          ZodAny: ZodAny2,
+          ZodUnknown: ZodUnknown2,
+          ZodNever: ZodNever2,
+          ZodVoid: ZodVoid2,
+          ZodArray: ZodArray2,
+          get objectUtil() {
+            return objectUtil2;
+          },
+          ZodObject: ZodObject2,
+          ZodUnion: ZodUnion2,
+          ZodDiscriminatedUnion: ZodDiscriminatedUnion2,
+          ZodIntersection: ZodIntersection2,
+          ZodTuple: ZodTuple2,
+          ZodRecord: ZodRecord2,
+          ZodMap: ZodMap2,
+          ZodSet: ZodSet2,
+          ZodFunction: ZodFunction2,
+          ZodLazy: ZodLazy2,
+          ZodLiteral: ZodLiteral2,
+          ZodEnum: ZodEnum2,
+          ZodNativeEnum: ZodNativeEnum2,
+          ZodPromise: ZodPromise2,
+          ZodEffects: ZodEffects2,
+          ZodTransformer: ZodEffects2,
+          ZodOptional: ZodOptional2,
+          ZodNullable: ZodNullable2,
+          ZodDefault: ZodDefault2,
+          ZodCatch: ZodCatch2,
+          ZodNaN: ZodNaN2,
+          BRAND: BRAND2,
+          ZodBranded: ZodBranded2,
+          ZodPipeline: ZodPipeline2,
+          custom: custom2,
+          Schema: ZodType2,
+          ZodSchema: ZodType2,
+          late: late2,
+          get ZodFirstPartyTypeKind() {
+            return ZodFirstPartyTypeKind2;
+          },
+          coerce: coerce2,
+          any: anyType2,
+          array: arrayType2,
+          bigint: bigIntType2,
+          boolean: booleanType2,
+          date: dateType2,
+          discriminatedUnion: discriminatedUnionType2,
+          effect: effectsType2,
+          "enum": enumType2,
+          "function": functionType2,
+          "instanceof": instanceOfType2,
+          intersection: intersectionType2,
+          lazy: lazyType2,
+          literal: literalType2,
+          map: mapType2,
+          nan: nanType2,
+          nativeEnum: nativeEnumType2,
+          never: neverType2,
+          "null": nullType2,
+          nullable: nullableType2,
+          number: numberType2,
+          object: objectType2,
+          oboolean: oboolean2,
+          onumber: onumber2,
+          optional: optionalType2,
+          ostring: ostring2,
+          pipeline: pipelineType2,
+          preprocess: preprocessType2,
+          promise: promiseType2,
+          record: recordType2,
+          set: setType2,
+          strictObject: strictObjectType2,
+          string: stringType2,
+          symbol: symbolType2,
+          transformer: effectsType2,
+          tuple: tupleType2,
+          "undefined": undefinedType2,
+          union: unionType2,
+          unknown: unknownType2,
+          "void": voidType2,
+          NEVER: NEVER2,
+          ZodIssueCode: ZodIssueCode2,
+          quotelessJson: quotelessJson2,
+          ZodError: ZodError2
+        });
+        var ContextValidator2 = mod2.array(mod2.string().or(mod2.record(mod2.any())));
+        var AchievementCriteriaValidator2 = mod2.object({
+          type: mod2.string().optional(),
+          narrative: mod2.string().optional()
+        });
+        var ImageValidator2 = mod2.string().or(
+          mod2.object({
+            id: mod2.string(),
+            type: mod2.string(),
+            caption: mod2.string().optional()
+          })
+        );
+        var GeoCoordinatesValidator2 = mod2.object({
+          type: mod2.string().min(1).or(mod2.string().array().nonempty()),
+          latitude: mod2.number(),
+          longitude: mod2.number()
+        });
+        var AddressValidator2 = mod2.object({
+          type: mod2.string().min(1).or(mod2.string().array().nonempty()),
+          addressCountry: mod2.string().optional(),
+          addressCountryCode: mod2.string().optional(),
+          addressRegion: mod2.string().optional(),
+          addressLocality: mod2.string().optional(),
+          streetAddress: mod2.string().optional(),
+          postOfficeBoxNumber: mod2.string().optional(),
+          postalCode: mod2.string().optional(),
+          geo: GeoCoordinatesValidator2.optional()
+        });
+        var IdentifierTypeValidator2 = mod2.enum([
+          "sourcedId",
+          "systemId",
+          "productId",
+          "userName",
+          "accountId",
+          "emailAddress",
+          "nationalIdentityNumber",
+          "isbn",
+          "issn",
+          "lisSourcedId",
+          "oneRosterSourcedId",
+          "sisSourcedId",
+          "ltiContextId",
+          "ltiDeploymentId",
+          "ltiToolId",
+          "ltiPlatformId",
+          "ltiUserId",
+          "identifier"
+        ]).or(mod2.string());
+        var IdentifierEntryValidator2 = mod2.object({
+          type: mod2.string().min(1).or(mod2.string().array().nonempty()),
+          identifier: mod2.string(),
+          identifierType: IdentifierTypeValidator2
+        });
+        var ProfileValidator2 = mod2.string().or(
+          mod2.object({
+            id: mod2.string().optional(),
+            type: mod2.string().or(mod2.string().array().nonempty().optional()),
+            name: mod2.string().optional(),
+            url: mod2.string().optional(),
+            phone: mod2.string().optional(),
+            description: mod2.string().optional(),
+            endorsement: mod2.any().array().optional(),
+            image: ImageValidator2.optional(),
+            email: mod2.string().email().optional(),
+            address: AddressValidator2.optional(),
+            otherIdentifier: IdentifierEntryValidator2.array().optional(),
+            official: mod2.string().optional(),
+            parentOrg: mod2.any().optional(),
+            familyName: mod2.string().optional(),
+            givenName: mod2.string().optional(),
+            additionalName: mod2.string().optional(),
+            patronymicName: mod2.string().optional(),
+            honorificPrefix: mod2.string().optional(),
+            honorificSuffix: mod2.string().optional(),
+            familyNamePrefix: mod2.string().optional(),
+            dateOfBirth: mod2.string().optional()
+          }).catchall(mod2.any())
+        );
+        var CredentialSubjectValidator2 = mod2.object({ id: mod2.string().optional() }).catchall(mod2.any());
+        var CredentialStatusValidator2 = mod2.object({ type: mod2.string(), id: mod2.string() }).catchall(mod2.any());
+        var CredentialSchemaValidator2 = mod2.object({ id: mod2.string(), type: mod2.string() }).catchall(mod2.any());
+        var RefreshServiceValidator2 = mod2.object({ id: mod2.string(), type: mod2.string() }).catchall(mod2.any());
+        var UnsignedVCValidator2 = mod2.object({
+          "@context": ContextValidator2,
+          id: mod2.string().optional(),
+          type: mod2.string().array().nonempty(),
+          issuer: ProfileValidator2,
+          issuanceDate: mod2.string(),
+          expirationDate: mod2.string().optional(),
+          credentialSubject: CredentialSubjectValidator2.or(CredentialSubjectValidator2.array()),
+          credentialStatus: CredentialStatusValidator2.optional(),
+          credentialSchema: CredentialSchemaValidator2.array().optional(),
+          refreshService: RefreshServiceValidator2.optional()
+        }).catchall(mod2.any());
+        var ProofValidator2 = mod2.object({
+          type: mod2.string(),
+          created: mod2.string(),
+          challenge: mod2.string().optional(),
+          domain: mod2.string().optional(),
+          nonce: mod2.string().optional(),
+          proofPurpose: mod2.string(),
+          verificationMethod: mod2.string(),
+          jws: mod2.string().optional()
+        }).catchall(mod2.any());
+        var VCValidator2 = UnsignedVCValidator2.extend({
+          proof: ProofValidator2.or(ProofValidator2.array())
+        });
+        var UnsignedVPValidator2 = mod2.object({
+          "@context": ContextValidator2,
+          id: mod2.string().optional(),
+          type: mod2.string().or(mod2.string().array().nonempty()),
+          verifiableCredential: VCValidator2.or(VCValidator2.array()).optional(),
+          holder: mod2.string().optional()
+        }).catchall(mod2.any());
+        var VPValidator2 = UnsignedVPValidator2.extend({
+          proof: ProofValidator2.or(ProofValidator2.array())
+        });
+        var JWKValidator2 = mod2.object({
+          kty: mod2.string(),
+          crv: mod2.string(),
+          x: mod2.string(),
+          y: mod2.string().optional(),
+          n: mod2.string().optional(),
+          d: mod2.string()
+        });
+        var JWERecipientHeaderValidator2 = mod2.object({
+          alg: mod2.string(),
+          iv: mod2.string(),
+          tag: mod2.string(),
+          epk: JWKValidator2.partial().optional(),
+          kid: mod2.string().optional(),
+          apv: mod2.string().optional(),
+          apu: mod2.string().optional()
+        });
+        var JWERecipientValidator2 = mod2.object({
+          header: JWERecipientHeaderValidator2,
+          encrypted_key: mod2.string()
+        });
+        var JWEValidator2 = mod2.object({
+          protected: mod2.string(),
+          iv: mod2.string(),
+          ciphertext: mod2.string(),
+          tag: mod2.string(),
+          aad: mod2.string().optional(),
+          recipients: JWERecipientValidator2.array().optional()
+        });
+        var VerificationMethodValidator2 = mod2.string().or(
+          mod2.object({
+            "@context": ContextValidator2.optional(),
+            id: mod2.string(),
+            type: mod2.string(),
+            controller: mod2.string(),
+            publicKeyJwk: JWKValidator2.optional(),
+            publicKeyBase58: mod2.string().optional(),
+            blockChainAccountId: mod2.string().optional()
+          }).catchall(mod2.any())
+        );
+        var ServiceValidator2 = mod2.object({
+          id: mod2.string(),
+          type: mod2.string().or(mod2.string().array().nonempty()),
+          serviceEndpoint: mod2.any().or(mod2.any().array().nonempty())
+        }).catchall(mod2.any());
+        var DidDocumentValidator2 = mod2.object({
+          "@context": ContextValidator2,
+          id: mod2.string(),
+          alsoKnownAs: mod2.string().optional(),
+          controller: mod2.string().or(mod2.string().array().nonempty()).optional(),
+          verificationMethod: VerificationMethodValidator2.array().optional(),
+          authentication: VerificationMethodValidator2.array().optional(),
+          assertionMethod: VerificationMethodValidator2.array().optional(),
+          keyAgreement: VerificationMethodValidator2.array().optional(),
+          capabilityInvocation: VerificationMethodValidator2.array().optional(),
+          capabilityDelegation: VerificationMethodValidator2.array().optional(),
+          publicKey: VerificationMethodValidator2.array().optional(),
+          service: ServiceValidator2.array().optional(),
+          proof: ProofValidator2.or(ProofValidator2.array()).optional()
+        }).catchall(mod2.any());
+        var AlignmentTargetTypeValidator2 = mod2.enum([
+          "ceasn:Competency",
+          "ceterms:Credential",
+          "CFItem",
+          "CFRubric",
+          "CFRubricCriterion",
+          "CFRubricCriterionLevel",
+          "CTDL"
+        ]).or(mod2.string());
+        var AlignmentValidator2 = mod2.object({
+          type: mod2.string().array().nonempty(),
+          targetCode: mod2.string().optional(),
+          targetDescription: mod2.string().optional(),
+          targetName: mod2.string(),
+          targetFramework: mod2.string().optional(),
+          targetType: AlignmentTargetTypeValidator2.optional(),
+          targetUrl: mod2.string()
+        });
+        var KnownAchievementTypeValidator2 = mod2.enum([
+          "Achievement",
+          "ApprenticeshipCertificate",
+          "Assessment",
+          "Assignment",
+          "AssociateDegree",
+          "Award",
+          "Badge",
+          "BachelorDegree",
+          "Certificate",
+          "CertificateOfCompletion",
+          "Certification",
+          "CommunityService",
+          "Competency",
+          "Course",
+          "CoCurricular",
+          "Degree",
+          "Diploma",
+          "DoctoralDegree",
+          "Fieldwork",
+          "GeneralEducationDevelopment",
+          "JourneymanCertificate",
+          "LearningProgram",
+          "License",
+          "Membership",
+          "ProfessionalDoctorate",
+          "QualityAssuranceCredential",
+          "MasterCertificate",
+          "MasterDegree",
+          "MicroCredential",
+          "ResearchDoctorate",
+          "SecondarySchoolDiploma"
+        ]);
+        var AchievementTypeValidator2 = KnownAchievementTypeValidator2.or(mod2.string());
+        var CriteriaValidator2 = mod2.object({ id: mod2.string().optional(), narrative: mod2.string().optional() }).catchall(mod2.any());
+        var EndorsementSubjectValidator2 = mod2.object({
+          id: mod2.string(),
+          type: mod2.string().array().nonempty(),
+          endorsementComment: mod2.string().optional()
+        });
+        var EndorsementCredentialValidator2 = UnsignedVCValidator2.extend({
+          credentialSubject: EndorsementSubjectValidator2,
+          proof: ProofValidator2.or(ProofValidator2.array()).optional()
+        });
+        var RelatedValidator2 = mod2.object({
+          id: mod2.string(),
+          "@language": mod2.string().optional(),
+          version: mod2.string().optional()
+        });
+        var ResultTypeValidator2 = mod2.enum([
+          "GradePointAverage",
+          "LetterGrade",
+          "Percent",
+          "PerformanceLevel",
+          "PredictedScore",
+          "RawScore",
+          "Result",
+          "RubricCriterion",
+          "RubricCriterionLevel",
+          "RubricScore",
+          "ScaledScore",
+          "Status"
+        ]).or(mod2.string());
+        var RubricCriterionValidator2 = mod2.object({
+          id: mod2.string(),
+          type: mod2.string().array().nonempty(),
+          alignment: AlignmentValidator2.array().optional(),
+          description: mod2.string().optional(),
+          level: mod2.string().optional(),
+          name: mod2.string(),
+          points: mod2.string().optional()
+        }).catchall(mod2.any());
+        var ResultDescriptionValidator2 = mod2.object({
+          id: mod2.string(),
+          type: mod2.string().array().nonempty(),
+          alignment: AlignmentValidator2.array().optional(),
+          allowedValue: mod2.string().array().optional(),
+          name: mod2.string(),
+          requiredLevel: mod2.string().optional(),
+          requiredValue: mod2.string().optional(),
+          resultType: ResultTypeValidator2,
+          rubricCriterionLevel: RubricCriterionValidator2.array().optional(),
+          valueMax: mod2.string().optional(),
+          valueMin: mod2.string().optional()
+        }).catchall(mod2.any());
+        var AchievementValidator2 = mod2.object({
+          id: mod2.string().optional(),
+          type: mod2.string().array().nonempty(),
+          alignment: AlignmentValidator2.array().optional(),
+          achievementType: AchievementTypeValidator2.optional(),
+          creator: ProfileValidator2.optional(),
+          creditsAvailable: mod2.number().optional(),
+          criteria: CriteriaValidator2,
+          description: mod2.string(),
+          endorsement: EndorsementCredentialValidator2.array().optional(),
+          fieldOfStudy: mod2.string().optional(),
+          humanCode: mod2.string().optional(),
+          image: ImageValidator2.optional(),
+          "@language": mod2.string().optional(),
+          name: mod2.string(),
+          otherIdentifier: IdentifierEntryValidator2.array().optional(),
+          related: RelatedValidator2.array().optional(),
+          resultDescription: ResultDescriptionValidator2.array().optional(),
+          specialization: mod2.string().optional(),
+          tag: mod2.string().array().optional(),
+          version: mod2.string().optional()
+        }).catchall(mod2.any());
+        var IdentityObjectValidator2 = mod2.object({
+          type: mod2.string(),
+          hashed: mod2.boolean(),
+          identityHash: mod2.string(),
+          identityType: mod2.string(),
+          salt: mod2.string().optional()
+        });
+        var ResultStatusTypeValidator2 = mod2.enum([
+          "Completed",
+          "Enrolled",
+          "Failed",
+          "InProgress",
+          "OnHold",
+          "Withdrew"
+        ]);
+        var ResultValidator2 = mod2.object({
+          type: mod2.string().array().nonempty(),
+          achievedLevel: mod2.string().optional(),
+          alignment: AlignmentValidator2.array().optional(),
+          resultDescription: mod2.string().optional(),
+          status: ResultStatusTypeValidator2.optional(),
+          value: mod2.string().optional()
+        }).catchall(mod2.any());
+        var AchievementSubjectValidator2 = mod2.object({
+          id: mod2.string().optional(),
+          type: mod2.string().array().nonempty(),
+          activityEndDate: mod2.string().optional(),
+          activityStartDate: mod2.string().optional(),
+          creditsEarned: mod2.number().optional(),
+          achievement: AchievementValidator2.optional(),
+          identifier: IdentityObjectValidator2.array().optional(),
+          image: ImageValidator2.optional(),
+          licenseNumber: mod2.string().optional(),
+          narrative: mod2.string().optional(),
+          result: ResultValidator2.array().optional(),
+          role: mod2.string().optional(),
+          source: ProfileValidator2.optional(),
+          term: mod2.string().optional()
+        }).catchall(mod2.any());
+        var EvidenceValidator2 = mod2.object({
+          id: mod2.string().optional(),
+          type: mod2.string().array().nonempty(),
+          narrative: mod2.string().optional(),
+          name: mod2.string().optional(),
+          description: mod2.string().optional(),
+          genre: mod2.string().optional(),
+          audience: mod2.string().optional()
+        }).catchall(mod2.any());
+        var UnsignedAchievementCredentialValidator2 = UnsignedVCValidator2.extend({
+          name: mod2.string().optional(),
+          description: mod2.string().optional(),
+          image: ImageValidator2.optional(),
+          credentialSubject: AchievementSubjectValidator2.or(
+            AchievementSubjectValidator2.array()
+          ),
+          endorsement: UnsignedVCValidator2.array().optional(),
+          evidence: EvidenceValidator2.array().optional()
+        });
+        var AchievementCredentialValidator2 = UnsignedAchievementCredentialValidator2.extend({
+          proof: ProofValidator2.or(ProofValidator2.array())
+        });
+        var VerificationCheckValidator2 = mod2.object({
+          checks: mod2.string().array(),
+          warnings: mod2.string().array(),
+          errors: mod2.string().array()
+        });
+        var VerificationStatusValidator2 = mod2.enum(["Success", "Failed", "Error"]);
+        var VerificationStatusEnum2 = VerificationStatusValidator2.enum;
+        var VerificationItemValidator2 = mod2.object({
+          check: mod2.string(),
+          status: VerificationStatusValidator2,
+          message: mod2.string().optional(),
+          details: mod2.string().optional()
+        });
+        var CredentialInfoValidator2 = mod2.object({
+          title: mod2.string().optional(),
+          createdAt: mod2.string().optional(),
+          issuer: ProfileValidator2.optional(),
+          issuee: ProfileValidator2.optional(),
+          credentialSubject: CredentialSubjectValidator2.optional()
+        });
+        var CredentialRecordValidator2 = mod2.object({ id: mod2.string(), uri: mod2.string() }).catchall(mod2.any());
+        var PaginationOptionsValidator2 = mod2.object({
+          limit: mod2.number(),
+          cursor: mod2.string().optional(),
+          sort: mod2.string().optional()
+        });
+        var PaginationResponseValidator2 = mod2.object({
+          cursor: mod2.string().optional(),
+          hasMore: mod2.boolean()
+        });
+        var EncryptedRecordValidator2 = mod2.object({ encryptedRecord: JWEValidator2, fields: mod2.string().array() }).catchall(mod2.any());
+        var PaginatedEncryptedRecordsValidator2 = PaginationResponseValidator2.extend({
+          records: EncryptedRecordValidator2.array()
+        });
+        var EncryptedCredentialRecordValidator2 = EncryptedRecordValidator2.extend({
+          id: mod2.string()
+        });
+        var PaginatedEncryptedCredentialRecordsValidator2 = PaginationResponseValidator2.extend({
+          records: EncryptedCredentialRecordValidator2.array()
+        });
+        var parseRegexString2 = /* @__PURE__ */ __name222((regexStr) => {
+          const match = regexStr.match(/^\/(.*)\/([gimsuy]*)$/);
+          if (!match)
+            throw new Error("Invalid RegExp string format");
+          return { pattern: match[1], flags: match[2] };
+        }, "parseRegexString");
+        var RegExpValidator2 = mod2.instanceof(RegExp).or(
+          mod2.string().refine(
+            (str) => {
+              try {
+                parseRegexString2(str);
+                return true;
+              } catch (e) {
+                return false;
+              }
+            },
+            {
+              message: "Invalid RegExp string format. Must be in format '/pattern/flags'"
+            }
+          ).transform((str) => {
+            const { pattern, flags } = parseRegexString2(str);
+            try {
+              return new RegExp(pattern, flags);
+            } catch (error) {
+              throw new Error(`Invalid RegExp: ${error.message}`);
+            }
+          })
+        );
+        var StringQuery2 = mod2.string().or(mod2.object({ $in: mod2.string().array() })).or(mod2.object({ $regex: RegExpValidator2 }));
+        var LCNProfileValidator2 = mod2.object({
+          profileId: mod2.string().min(3).max(40),
+          displayName: mod2.string().default(""),
+          shortBio: mod2.string().default(""),
+          bio: mod2.string().default(""),
+          did: mod2.string(),
+          email: mod2.string().optional(),
+          image: mod2.string().optional(),
+          heroImage: mod2.string().optional(),
+          websiteLink: mod2.string().optional(),
+          isServiceProfile: mod2.boolean().default(false).optional(),
+          type: mod2.string().optional(),
+          notificationsWebhook: mod2.string().url().startsWith("http").optional()
+        });
+        var LCNProfileQueryValidator2 = mod2.object({
+          profileId: StringQuery2,
+          displayName: StringQuery2,
+          shortBio: StringQuery2,
+          bio: StringQuery2,
+          email: StringQuery2,
+          websiteLink: StringQuery2,
+          isServiceProfile: mod2.boolean(),
+          type: StringQuery2
+        }).partial();
+        var PaginatedLCNProfilesValidator2 = PaginationResponseValidator2.extend({
+          records: LCNProfileValidator2.array()
+        });
+        var LCNProfileConnectionStatusEnum2 = mod2.enum([
+          "CONNECTED",
+          "PENDING_REQUEST_SENT",
+          "PENDING_REQUEST_RECEIVED",
+          "NOT_CONNECTED"
+        ]);
+        var SentCredentialInfoValidator2 = mod2.object({
+          uri: mod2.string(),
+          to: mod2.string(),
+          from: mod2.string(),
+          sent: mod2.string().datetime(),
+          received: mod2.string().datetime().optional()
+        });
+        var BoostPermissionsValidator2 = mod2.object({
+          role: mod2.string(),
+          canEdit: mod2.boolean(),
+          canIssue: mod2.boolean(),
+          canRevoke: mod2.boolean(),
+          canManagePermissions: mod2.boolean(),
+          canIssueChildren: mod2.string(),
+          canCreateChildren: mod2.string(),
+          canEditChildren: mod2.string(),
+          canRevokeChildren: mod2.string(),
+          canManageChildrenPermissions: mod2.string(),
+          canViewAnalytics: mod2.boolean()
+        });
+        var LCNBoostStatus2 = mod2.enum(["DRAFT", "LIVE"]);
+        var BoostValidator2 = mod2.object({
+          uri: mod2.string(),
+          name: mod2.string().optional(),
+          type: mod2.string().optional(),
+          category: mod2.string().optional(),
+          status: LCNBoostStatus2.optional(),
+          autoConnectRecipients: mod2.boolean().optional(),
+          meta: mod2.record(mod2.any()).optional(),
+          claimPermissions: BoostPermissionsValidator2.optional()
+        });
+        var BoostQueryValidator2 = mod2.object({
+          uri: StringQuery2,
+          name: StringQuery2,
+          type: StringQuery2,
+          category: StringQuery2,
+          meta: mod2.record(StringQuery2),
+          status: LCNBoostStatus2.or(mod2.object({ $in: LCNBoostStatus2.array() })),
+          autoConnectRecipients: mod2.boolean()
+        }).partial();
+        var PaginatedBoostsValidator2 = PaginationResponseValidator2.extend({
+          records: BoostValidator2.array()
+        });
+        var BoostRecipientValidator2 = mod2.object({
+          to: LCNProfileValidator2,
+          from: mod2.string(),
+          received: mod2.string().optional(),
+          uri: mod2.string().optional()
+        });
+        var PaginatedBoostRecipientsValidator2 = PaginationResponseValidator2.extend({
+          records: BoostRecipientValidator2.array()
+        });
+        var LCNBoostClaimLinkSigningAuthorityValidator2 = mod2.object({
+          endpoint: mod2.string(),
+          name: mod2.string(),
+          did: mod2.string().optional()
+        });
+        var LCNBoostClaimLinkOptionsValidator2 = mod2.object({
+          ttlSeconds: mod2.number().optional(),
+          totalUses: mod2.number().optional()
+        });
+        var LCNSigningAuthorityValidator2 = mod2.object({
+          endpoint: mod2.string()
+        });
+        var LCNSigningAuthorityForUserValidator2 = mod2.object({
+          signingAuthority: LCNSigningAuthorityValidator2,
+          relationship: mod2.object({
+            name: mod2.string().max(15).regex(/^[a-z0-9-]+$/, {
+              message: "The input string must contain only lowercase letters, numbers, and hyphens."
+            }),
+            did: mod2.string()
+          })
+        });
+        var ConsentFlowTermsStatusValidator2 = mod2.enum(["live", "stale", "withdrawn"]);
+        var ConsentFlowContractValidator2 = mod2.object({
+          read: mod2.object({
+            anonymize: mod2.boolean().optional(),
+            credentials: mod2.object({ categories: mod2.record(mod2.object({ required: mod2.boolean() })).default({}) }).default({}),
+            personal: mod2.record(mod2.object({ required: mod2.boolean() })).default({})
+          }).default({}),
+          write: mod2.object({
+            credentials: mod2.object({ categories: mod2.record(mod2.object({ required: mod2.boolean() })).default({}) }).default({}),
+            personal: mod2.record(mod2.object({ required: mod2.boolean() })).default({})
+          }).default({})
+        });
+        var ConsentFlowContractDetailsValidator2 = mod2.object({
+          contract: ConsentFlowContractValidator2,
+          owner: LCNProfileValidator2,
+          name: mod2.string(),
+          subtitle: mod2.string().optional(),
+          description: mod2.string().optional(),
+          reasonForAccessing: mod2.string().optional(),
+          image: mod2.string().optional(),
+          uri: mod2.string(),
+          createdAt: mod2.string(),
+          updatedAt: mod2.string(),
+          expiresAt: mod2.string().optional()
+        });
+        var PaginatedConsentFlowContractsValidator2 = PaginationResponseValidator2.extend({
+          records: ConsentFlowContractDetailsValidator2.omit({ owner: true }).array()
+        });
+        var ConsentFlowContractDataValidator2 = mod2.object({
+          credentials: mod2.object({ categories: mod2.record(mod2.string().array()).default({}) }),
+          personal: mod2.record(mod2.string()).default({}),
+          date: mod2.string()
+        });
+        var PaginatedConsentFlowDataValidator2 = PaginationResponseValidator2.extend({
+          records: ConsentFlowContractDataValidator2.array()
+        });
+        var ConsentFlowTermValidator2 = mod2.object({
+          sharing: mod2.boolean().optional(),
+          shared: mod2.string().array().optional(),
+          shareAll: mod2.boolean().optional(),
+          shareUntil: mod2.string().optional()
+        });
+        var ConsentFlowTermsValidator2 = mod2.object({
+          read: mod2.object({
+            anonymize: mod2.boolean().optional(),
+            credentials: mod2.object({
+              shareAll: mod2.boolean().optional(),
+              sharing: mod2.boolean().optional(),
+              categories: mod2.record(ConsentFlowTermValidator2).default({})
+            }).default({}),
+            personal: mod2.record(mod2.string()).default({})
+          }).default({}),
+          write: mod2.object({
+            credentials: mod2.object({ categories: mod2.record(mod2.boolean()).default({}) }).default({}),
+            personal: mod2.record(mod2.boolean()).default({})
+          }).default({})
+        });
+        var PaginatedConsentFlowTermsValidator2 = PaginationResponseValidator2.extend({
+          records: mod2.object({
+            expiresAt: mod2.string().optional(),
+            oneTime: mod2.boolean().optional(),
+            terms: ConsentFlowTermsValidator2,
+            contract: ConsentFlowContractDetailsValidator2,
+            uri: mod2.string(),
+            consenter: LCNProfileValidator2,
+            status: ConsentFlowTermsStatusValidator2
+          }).array()
+        });
+        var ConsentFlowContractQueryValidator2 = mod2.object({
+          read: mod2.object({
+            anonymize: mod2.boolean().optional(),
+            credentials: mod2.object({
+              categories: mod2.record(mod2.object({ required: mod2.boolean().optional() })).optional()
+            }).optional(),
+            personal: mod2.record(mod2.object({ required: mod2.boolean().optional() })).optional()
+          }).optional(),
+          write: mod2.object({
+            credentials: mod2.object({
+              categories: mod2.record(mod2.object({ required: mod2.boolean().optional() })).optional()
+            }).optional(),
+            personal: mod2.record(mod2.object({ required: mod2.boolean().optional() })).optional()
+          }).optional()
+        });
+        var ConsentFlowDataQueryValidator2 = mod2.object({
+          anonymize: mod2.boolean().optional(),
+          credentials: mod2.object({ categories: mod2.record(mod2.boolean()).optional() }).optional(),
+          personal: mod2.record(mod2.boolean()).optional()
+        });
+        var ConsentFlowTermsQueryValidator2 = mod2.object({
+          read: mod2.object({
+            anonymize: mod2.boolean().optional(),
+            credentials: mod2.object({
+              shareAll: mod2.boolean().optional(),
+              sharing: mod2.boolean().optional(),
+              categories: mod2.record(ConsentFlowTermValidator2.optional()).optional()
+            }).optional(),
+            personal: mod2.record(mod2.string()).optional()
+          }).optional(),
+          write: mod2.object({
+            credentials: mod2.object({ categories: mod2.record(mod2.boolean()).optional() }).optional(),
+            personal: mod2.record(mod2.boolean()).optional()
+          }).optional()
+        });
+        var ConsentFlowTransactionActionValidator2 = mod2.enum([
+          "consent",
+          "update",
+          "sync",
+          "withdraw"
+        ]);
+        var ConsentFlowTransactionsQueryValidator2 = mod2.object({
+          terms: ConsentFlowTermsQueryValidator2.optional(),
+          action: ConsentFlowTransactionActionValidator2.or(
+            ConsentFlowTransactionActionValidator2.array()
+          ).optional(),
+          date: mod2.object({ $gt: mod2.string() }).or(mod2.object({ $lt: mod2.string() })).or(mod2.object({ $eq: mod2.string() })).optional(),
+          expiresAt: mod2.object({ $gt: mod2.string() }).or(mod2.object({ $lt: mod2.string() })).or(mod2.object({ $eq: mod2.string() })).optional(),
+          oneTime: mod2.boolean().optional()
+        });
+        var ConsentFlowTransactionValidator2 = mod2.object({
+          expiresAt: mod2.string().optional(),
+          oneTime: mod2.boolean().optional(),
+          terms: ConsentFlowTermsValidator2.optional(),
+          id: mod2.string(),
+          action: ConsentFlowTransactionActionValidator2,
+          date: mod2.string()
+        });
+        var PaginatedConsentFlowTransactionsValidator2 = PaginationResponseValidator2.extend({
+          records: ConsentFlowTransactionValidator2.array()
+        });
+        var LCNNotificationTypeEnumValidator2 = mod2.enum([
+          "CONNECTION_REQUEST",
+          "CONNECTION_ACCEPTED",
+          "CREDENTIAL_RECEIVED",
+          "CREDENTIAL_ACCEPTED",
+          "BOOST_RECEIVED",
+          "BOOST_ACCEPTED",
+          "PRESENTATION_REQUEST",
+          "PRESENTATION_RECEIVED",
+          "CONSENT_FLOW_TRANSACTION"
+        ]);
+        var LCNNotificationMessageValidator2 = mod2.object({
+          title: mod2.string().optional(),
+          body: mod2.string().optional()
+        });
+        var LCNNotificationDataValidator2 = mod2.object({
+          vcUris: mod2.array(mod2.string()).optional(),
+          vpUris: mod2.array(mod2.string()).optional(),
+          transaction: ConsentFlowTransactionValidator2.optional()
+        });
+        var LCNNotificationValidator2 = mod2.object({
+          type: LCNNotificationTypeEnumValidator2,
+          to: LCNProfileValidator2.partial().and(mod2.object({ did: mod2.string() })),
+          from: LCNProfileValidator2.partial().and(mod2.object({ did: mod2.string() })),
+          message: LCNNotificationMessageValidator2.optional(),
+          data: LCNNotificationDataValidator2.optional(),
+          sent: mod2.string().datetime().optional()
+        });
+      }
+    });
+    var require_dist2 = __commonJS2({
+      "../learn-card-types/dist/index.js"(exports2, module2) {
+        "use strict";
+        if (false) {
+          module2.exports = null;
+        } else {
+          module2.exports = require_types_cjs_development();
+        }
+      }
+    });
+    var src_exports = {};
+    __export(src_exports, {
+      RegExpTransformer: () => RegExpTransformer2,
+      isEncrypted: () => isEncrypted,
+      isHex: () => isHex
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_types2 = __toESM2(require_dist2());
+    var isHex = /* @__PURE__ */ __name22((str) => /^[0-9a-f]+$/i.test(str), "isHex");
+    var isEncrypted = /* @__PURE__ */ __name22((item) => {
+      return import_types2.JWEValidator.safeParse(item).success;
+    }, "isEncrypted");
+    var RegExpTransformer2 = {
+      serialize(object) {
+        return JSON.stringify(object, (_key, value) => {
+          if (value instanceof RegExp)
+            return value.toString();
+          return value;
+        });
+      },
+      deserialize(object) {
+        if (typeof object !== "string")
+          return object;
+        return JSON.parse(object, (_key, value) => {
+          if (typeof value === "string") {
+            const match = value.match(/^\/(.*)\/([gimsuy]*)$/);
+            if (match) {
+              try {
+                return new RegExp(match[1], match[2]);
+              } catch (error) {
+                console.warn(`Failed to parse RegExp: ${error}`);
+                return value;
+              }
+            }
+          }
+          return value;
+        });
+      }
+    };
+  }
+});
+var require_dist = __commonJS({
+  "../../learn-card-helpers/dist/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_helpers_cjs_development();
+    }
+  }
+});
+var import_helpers = __toESM(require_dist());
 var callbackLink = /* @__PURE__ */ __name2((callback) => {
   return () => {
     return ({ next, op }) => {
@@ -1174,6 +5463,7 @@ var callbackLink = /* @__PURE__ */ __name2((callback) => {
 var getClient = /* @__PURE__ */ __name2(async (url, didAuthFunction) => {
   let challenges = [];
   const challengeRequester = createTRPCProxyClient({
+    transformer: import_helpers.RegExpTransformer,
     links: [
       httpBatchLink({
         url,
@@ -1187,6 +5477,7 @@ var getClient = /* @__PURE__ */ __name2(async (url, didAuthFunction) => {
   }, "getChallenges");
   challenges = await getChallenges();
   const trpc = createTRPCProxyClient({
+    transformer: import_helpers.RegExpTransformer,
     links: [
       callbackLink(async () => {
         challenges = await getChallenges();
@@ -4528,6 +8819,8 @@ var mod = /* @__PURE__ */ Object.freeze({
 });
 
 // ../../learn-card-types/dist/types.esm.js
+var __defProp3 = Object.defineProperty;
+var __name3 = /* @__PURE__ */ __name((target, value) => __defProp3(target, "name", { value, configurable: true }), "__name");
 var ContextValidator = mod.array(mod.string().or(mod.record(mod.any())));
 var AchievementCriteriaValidator = mod.object({
   type: mod.string().optional(),
@@ -4931,6 +9224,35 @@ var EncryptedCredentialRecordValidator = EncryptedRecordValidator.extend({
 var PaginatedEncryptedCredentialRecordsValidator = PaginationResponseValidator.extend({
   records: EncryptedCredentialRecordValidator.array()
 });
+var parseRegexString = /* @__PURE__ */ __name3((regexStr) => {
+  const match = regexStr.match(/^\/(.*)\/([gimsuy]*)$/);
+  if (!match)
+    throw new Error("Invalid RegExp string format");
+  return { pattern: match[1], flags: match[2] };
+}, "parseRegexString");
+var RegExpValidator = mod.instanceof(RegExp).or(
+  mod.string().refine(
+    (str) => {
+      try {
+        parseRegexString(str);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    {
+      message: "Invalid RegExp string format. Must be in format '/pattern/flags'"
+    }
+  ).transform((str) => {
+    const { pattern, flags } = parseRegexString(str);
+    try {
+      return new RegExp(pattern, flags);
+    } catch (error) {
+      throw new Error(`Invalid RegExp: ${error.message}`);
+    }
+  })
+);
+var StringQuery = mod.string().or(mod.object({ $in: mod.string().array() })).or(mod.object({ $regex: RegExpValidator }));
 var LCNProfileValidator = mod.object({
   profileId: mod.string().min(3).max(40),
   displayName: mod.string().default(""),
@@ -4945,6 +9267,16 @@ var LCNProfileValidator = mod.object({
   type: mod.string().optional(),
   notificationsWebhook: mod.string().url().startsWith("http").optional()
 });
+var LCNProfileQueryValidator = mod.object({
+  profileId: StringQuery,
+  displayName: StringQuery,
+  shortBio: StringQuery,
+  bio: StringQuery,
+  email: StringQuery,
+  websiteLink: StringQuery,
+  isServiceProfile: mod.boolean(),
+  type: StringQuery
+}).partial();
 var PaginatedLCNProfilesValidator = PaginationResponseValidator.extend({
   records: LCNProfileValidator.array()
 });
@@ -4985,7 +9317,6 @@ var BoostValidator = mod.object({
   meta: mod.record(mod.any()).optional(),
   claimPermissions: BoostPermissionsValidator.optional()
 });
-var StringQuery = mod.string().or(mod.object({ $in: mod.string().array() })).or(mod.object({ $regex: mod.instanceof(RegExp) }));
 var BoostQueryValidator = mod.object({
   uri: StringQuery,
   name: StringQuery,
@@ -5001,7 +9332,8 @@ var PaginatedBoostsValidator = PaginationResponseValidator.extend({
 var BoostRecipientValidator = mod.object({
   to: LCNProfileValidator,
   from: mod.string(),
-  received: mod.string().optional()
+  received: mod.string().optional(),
+  uri: mod.string().optional()
 });
 var PaginatedBoostRecipientsValidator = PaginationResponseValidator.extend({
   records: BoostRecipientValidator.array()
@@ -5575,14 +9907,15 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
           includeUnacceptedBoosts
         });
       },
-      getPaginatedBoostRecipients: async (_learnCard, uri, limit = 25, cursor = void 0, includeUnacceptedBoosts = true) => {
+      getPaginatedBoostRecipients: async (_learnCard, uri, limit = 25, cursor = void 0, includeUnacceptedBoosts = true, query) => {
         if (!userData)
           throw new Error("Please make an account first!");
         return client.boost.getPaginatedBoostRecipients.query({
           uri,
           limit,
           cursor,
-          includeUnacceptedBoosts
+          includeUnacceptedBoosts,
+          query
         });
       },
       countBoostRecipients: async (_learnCard, uri, includeUnacceptedBoosts = true) => {