@meetsmore-oss/use-ai-plugin-workflows 1.2.1

package/dist/index.js

@@ -0,0 +1,4821 @@
+// src/WorkflowsPlugin.ts
+import { logger } from "@meetsmore-oss/use-ai-server";
+
+// ../core/dist/index.js
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_util = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getParsedType = exports.ZodParsedType = exports.objectUtil = exports.util = undefined;
+  var util;
+  (function(util2) {
+    util2.assertEqual = (_) => {};
+    function assertIs(_arg) {}
+    util2.assertIs = assertIs;
+    function assertNever(_x) {
+      throw new Error;
+    }
+    util2.assertNever = assertNever;
+    util2.arrayToEnum = (items) => {
+      const obj = {};
+      for (const item of items) {
+        obj[item] = item;
+      }
+      return obj;
+    };
+    util2.getValidEnumValues = (obj) => {
+      const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+      const filtered = {};
+      for (const k of validKeys) {
+        filtered[k] = obj[k];
+      }
+      return util2.objectValues(filtered);
+    };
+    util2.objectValues = (obj) => {
+      return util2.objectKeys(obj).map(function(e) {
+        return obj[e];
+      });
+    };
+    util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+      const keys = [];
+      for (const key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          keys.push(key);
+        }
+      }
+      return keys;
+    };
+    util2.find = (arr, checker) => {
+      for (const item of arr) {
+        if (checker(item))
+          return item;
+      }
+      return;
+    };
+    util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+      return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+    }
+    util2.joinValues = joinValues;
+    util2.jsonStringifyReplacer = (_, value) => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    };
+  })(util || (exports.util = util = {}));
+  var objectUtil;
+  (function(objectUtil2) {
+    objectUtil2.mergeShapes = (first, second) => {
+      return {
+        ...first,
+        ...second
+      };
+    };
+  })(objectUtil || (exports.objectUtil = objectUtil = {}));
+  exports.ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set"
+  ]);
+  var getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+      case "undefined":
+        return exports.ZodParsedType.undefined;
+      case "string":
+        return exports.ZodParsedType.string;
+      case "number":
+        return Number.isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
+      case "boolean":
+        return exports.ZodParsedType.boolean;
+      case "function":
+        return exports.ZodParsedType.function;
+      case "bigint":
+        return exports.ZodParsedType.bigint;
+      case "symbol":
+        return exports.ZodParsedType.symbol;
+      case "object":
+        if (Array.isArray(data)) {
+          return exports.ZodParsedType.array;
+        }
+        if (data === null) {
+          return exports.ZodParsedType.null;
+        }
+        if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+          return exports.ZodParsedType.promise;
+        }
+        if (typeof Map !== "undefined" && data instanceof Map) {
+          return exports.ZodParsedType.map;
+        }
+        if (typeof Set !== "undefined" && data instanceof Set) {
+          return exports.ZodParsedType.set;
+        }
+        if (typeof Date !== "undefined" && data instanceof Date) {
+          return exports.ZodParsedType.date;
+        }
+        return exports.ZodParsedType.object;
+      default:
+        return exports.ZodParsedType.unknown;
+    }
+  };
+  exports.getParsedType = getParsedType;
+});
+var require_ZodError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = undefined;
+  var util_js_1 = require_util();
+  exports.ZodIssueCode = util_js_1.util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite"
+  ]);
+  var quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+  };
+  exports.quotelessJson = quotelessJson;
+
+  class ZodError extends Error {
+    get errors() {
+      return this.issues;
+    }
+    constructor(issues) {
+      super();
+      this.issues = [];
+      this.addIssue = (sub) => {
+        this.issues = [...this.issues, sub];
+      };
+      this.addIssues = (subs = []) => {
+        this.issues = [...this.issues, ...subs];
+      };
+      const actualProto = new.target.prototype;
+      if (Object.setPrototypeOf) {
+        Object.setPrototypeOf(this, actualProto);
+      } else {
+        this.__proto__ = actualProto;
+      }
+      this.name = "ZodError";
+      this.issues = issues;
+    }
+    format(_mapper) {
+      const mapper = _mapper || function(issue) {
+        return issue.message;
+      };
+      const fieldErrors = { _errors: [] };
+      const processError = (error) => {
+        for (const issue of error.issues) {
+          if (issue.code === "invalid_union") {
+            issue.unionErrors.map(processError);
+          } else if (issue.code === "invalid_return_type") {
+            processError(issue.returnTypeError);
+          } else if (issue.code === "invalid_arguments") {
+            processError(issue.argumentsError);
+          } else if (issue.path.length === 0) {
+            fieldErrors._errors.push(mapper(issue));
+          } else {
+            let curr = fieldErrors;
+            let i = 0;
+            while (i < issue.path.length) {
+              const el = issue.path[i];
+              const terminal = i === issue.path.length - 1;
+              if (!terminal) {
+                curr[el] = curr[el] || { _errors: [] };
+              } else {
+                curr[el] = curr[el] || { _errors: [] };
+                curr[el]._errors.push(mapper(issue));
+              }
+              curr = curr[el];
+              i++;
+            }
+          }
+        }
+      };
+      processError(this);
+      return fieldErrors;
+    }
+    static assert(value) {
+      if (!(value instanceof ZodError)) {
+        throw new Error(`Not a ZodError: ${value}`);
+      }
+    }
+    toString() {
+      return this.message;
+    }
+    get message() {
+      return JSON.stringify(this.issues, util_js_1.util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+      return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+      const fieldErrors = {};
+      const formErrors = [];
+      for (const sub of this.issues) {
+        if (sub.path.length > 0) {
+          const firstEl = sub.path[0];
+          fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+          fieldErrors[firstEl].push(mapper(sub));
+        } else {
+          formErrors.push(mapper(sub));
+        }
+      }
+      return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+      return this.flatten();
+    }
+  }
+  exports.ZodError = ZodError;
+  ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+  };
+});
+var require_en = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var ZodError_js_1 = require_ZodError();
+  var util_js_1 = require_util();
+  var errorMap = (issue, _ctx) => {
+    let message;
+    switch (issue.code) {
+      case ZodError_js_1.ZodIssueCode.invalid_type:
+        if (issue.received === util_js_1.ZodParsedType.undefined) {
+          message = "Required";
+        } else {
+          message = `Expected ${issue.expected}, received ${issue.received}`;
+        }
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_literal:
+        message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util_js_1.util.jsonStringifyReplacer)}`;
+        break;
+      case ZodError_js_1.ZodIssueCode.unrecognized_keys:
+        message = `Unrecognized key(s) in object: ${util_js_1.util.joinValues(issue.keys, ", ")}`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_union:
+        message = `Invalid input`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_union_discriminator:
+        message = `Invalid discriminator value. Expected ${util_js_1.util.joinValues(issue.options)}`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_enum_value:
+        message = `Invalid enum value. Expected ${util_js_1.util.joinValues(issue.options)}, received '${issue.received}'`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_arguments:
+        message = `Invalid function arguments`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_return_type:
+        message = `Invalid function return type`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_date:
+        message = `Invalid date`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_string:
+        if (typeof issue.validation === "object") {
+          if ("includes" in issue.validation) {
+            message = `Invalid input: must include "${issue.validation.includes}"`;
+            if (typeof issue.validation.position === "number") {
+              message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+            }
+          } else if ("startsWith" in issue.validation) {
+            message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+          } else if ("endsWith" in issue.validation) {
+            message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+          } else {
+            util_js_1.util.assertNever(issue.validation);
+          }
+        } else if (issue.validation !== "regex") {
+          message = `Invalid ${issue.validation}`;
+        } else {
+          message = "Invalid";
+        }
+        break;
+      case ZodError_js_1.ZodIssueCode.too_small:
+        if (issue.type === "array")
+          message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+        else if (issue.type === "string")
+          message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+        else if (issue.type === "number")
+          message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+        else if (issue.type === "bigint")
+          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(Number(issue.minimum))}`;
+        else
+          message = "Invalid input";
+        break;
+      case ZodError_js_1.ZodIssueCode.too_big:
+        if (issue.type === "array")
+          message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+        else if (issue.type === "string")
+          message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+        else if (issue.type === "number")
+          message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+        else if (issue.type === "bigint")
+          message = `BigInt 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(Number(issue.maximum))}`;
+        else
+          message = "Invalid input";
+        break;
+      case ZodError_js_1.ZodIssueCode.custom:
+        message = `Invalid input`;
+        break;
+      case ZodError_js_1.ZodIssueCode.invalid_intersection_types:
+        message = `Intersection results could not be merged`;
+        break;
+      case ZodError_js_1.ZodIssueCode.not_multiple_of:
+        message = `Number must be a multiple of ${issue.multipleOf}`;
+        break;
+      case ZodError_js_1.ZodIssueCode.not_finite:
+        message = "Number must be finite";
+        break;
+      default:
+        message = _ctx.defaultError;
+        util_js_1.util.assertNever(issue);
+    }
+    return { message };
+  };
+  exports.default = errorMap;
+});
+var require_errors = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.defaultErrorMap = undefined;
+  exports.setErrorMap = setErrorMap;
+  exports.getErrorMap = getErrorMap;
+  var en_js_1 = __importDefault(require_en());
+  exports.defaultErrorMap = en_js_1.default;
+  var overrideErrorMap = en_js_1.default;
+  function setErrorMap(map) {
+    overrideErrorMap = map;
+  }
+  function getErrorMap() {
+    return overrideErrorMap;
+  }
+});
+var require_parseUtil = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.EMPTY_PATH = exports.makeIssue = undefined;
+  exports.addIssueToContext = addIssueToContext;
+  var errors_js_1 = require_errors();
+  var en_js_1 = __importDefault(require_en());
+  var makeIssue = (params) => {
+    const { data, path, errorMaps, issueData } = params;
+    const fullPath = [...path, ...issueData.path || []];
+    const fullIssue = {
+      ...issueData,
+      path: fullPath
+    };
+    if (issueData.message !== undefined) {
+      return {
+        ...issueData,
+        path: fullPath,
+        message: issueData.message
+      };
+    }
+    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: errorMessage
+    };
+  };
+  exports.makeIssue = makeIssue;
+  exports.EMPTY_PATH = [];
+  function addIssueToContext(ctx, issueData) {
+    const overrideMap = (0, errors_js_1.getErrorMap)();
+    const issue = (0, exports.makeIssue)({
+      issueData,
+      data: ctx.data,
+      path: ctx.path,
+      errorMaps: [
+        ctx.common.contextualErrorMap,
+        ctx.schemaErrorMap,
+        overrideMap,
+        overrideMap === en_js_1.default ? undefined : en_js_1.default
+      ].filter((x) => !!x)
+    });
+    ctx.common.issues.push(issue);
+  }
+
+  class ParseStatus {
+    constructor() {
+      this.value = "valid";
+    }
+    dirty() {
+      if (this.value === "valid")
+        this.value = "dirty";
+    }
+    abort() {
+      if (this.value !== "aborted")
+        this.value = "aborted";
+    }
+    static mergeArray(status, results) {
+      const arrayValue = [];
+      for (const s of results) {
+        if (s.status === "aborted")
+          return exports.INVALID;
+        if (s.status === "dirty")
+          status.dirty();
+        arrayValue.push(s.value);
+      }
+      return { status: status.value, value: arrayValue };
+    }
+    static async mergeObjectAsync(status, pairs) {
+      const syncPairs = [];
+      for (const pair of pairs) {
+        const key = await pair.key;
+        const value = await pair.value;
+        syncPairs.push({
+          key,
+          value
+        });
+      }
+      return ParseStatus.mergeObjectSync(status, syncPairs);
+    }
+    static mergeObjectSync(status, pairs) {
+      const finalObject = {};
+      for (const pair of pairs) {
+        const { key, value } = pair;
+        if (key.status === "aborted")
+          return exports.INVALID;
+        if (value.status === "aborted")
+          return exports.INVALID;
+        if (key.status === "dirty")
+          status.dirty();
+        if (value.status === "dirty")
+          status.dirty();
+        if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
+          finalObject[key.value] = value.value;
+        }
+      }
+      return { status: status.value, value: finalObject };
+    }
+  }
+  exports.ParseStatus = ParseStatus;
+  exports.INVALID = Object.freeze({
+    status: "aborted"
+  });
+  var DIRTY = (value) => ({ status: "dirty", value });
+  exports.DIRTY = DIRTY;
+  var OK = (value) => ({ status: "valid", value });
+  exports.OK = OK;
+  var isAborted = (x) => x.status === "aborted";
+  exports.isAborted = isAborted;
+  var isDirty = (x) => x.status === "dirty";
+  exports.isDirty = isDirty;
+  var isValid = (x) => x.status === "valid";
+  exports.isValid = isValid;
+  var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+  exports.isAsync = isAsync;
+});
+var require_typeAliases = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+var require_errorUtil = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.errorUtil = undefined;
+  var errorUtil;
+  (function(errorUtil2) {
+    errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
+  })(errorUtil || (exports.errorUtil = errorUtil = {}));
+});
+var require_types = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.discriminatedUnion = exports.date = exports.boolean = exports.bigint = exports.array = exports.any = exports.coerce = exports.ZodFirstPartyTypeKind = exports.late = exports.ZodSchema = exports.Schema = exports.ZodReadonly = exports.ZodPipeline = exports.ZodBranded = exports.BRAND = exports.ZodNaN = exports.ZodCatch = exports.ZodDefault = exports.ZodNullable = exports.ZodOptional = exports.ZodTransformer = exports.ZodEffects = exports.ZodPromise = exports.ZodNativeEnum = exports.ZodEnum = exports.ZodLiteral = exports.ZodLazy = exports.ZodFunction = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodDate = exports.ZodBoolean = exports.ZodBigInt = exports.ZodNumber = exports.ZodString = exports.ZodType = undefined;
+  exports.NEVER = exports.void = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.symbol = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.pipeline = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports.null = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports.instanceof = exports.function = exports.enum = exports.effect = undefined;
+  exports.datetimeRegex = datetimeRegex;
+  exports.custom = custom;
+  var ZodError_js_1 = require_ZodError();
+  var errors_js_1 = require_errors();
+  var errorUtil_js_1 = require_errorUtil();
+  var parseUtil_js_1 = require_parseUtil();
+  var util_js_1 = require_util();
+
+  class ParseInputLazyPath {
+    constructor(parent, value, path, key) {
+      this._cachedPath = [];
+      this.parent = parent;
+      this.data = value;
+      this._path = path;
+      this._key = key;
+    }
+    get path() {
+      if (!this._cachedPath.length) {
+        if (Array.isArray(this._key)) {
+          this._cachedPath.push(...this._path, ...this._key);
+        } else {
+          this._cachedPath.push(...this._path, this._key);
+        }
+      }
+      return this._cachedPath;
+    }
+  }
+  var handleResult = (ctx, result) => {
+    if ((0, parseUtil_js_1.isValid)(result)) {
+      return { success: true, data: result.value };
+    } else {
+      if (!ctx.common.issues.length) {
+        throw new Error("Validation failed but no issues detected.");
+      }
+      return {
+        success: false,
+        get error() {
+          if (this._error)
+            return this._error;
+          const error = new ZodError_js_1.ZodError(ctx.common.issues);
+          this._error = error;
+          return this._error;
+        }
+      };
+    }
+  };
+  function processCreateParams(params) {
+    if (!params)
+      return {};
+    const { errorMap, invalid_type_error, required_error, description } = params;
+    if (errorMap && (invalid_type_error || required_error)) {
+      throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+    }
+    if (errorMap)
+      return { errorMap, description };
+    const customMap = (iss, ctx) => {
+      const { message } = params;
+      if (iss.code === "invalid_enum_value") {
+        return { message: message ?? ctx.defaultError };
+      }
+      if (typeof ctx.data === "undefined") {
+        return { message: message ?? required_error ?? ctx.defaultError };
+      }
+      if (iss.code !== "invalid_type")
+        return { message: ctx.defaultError };
+      return { message: message ?? invalid_type_error ?? ctx.defaultError };
+    };
+    return { errorMap: customMap, description };
+  }
+
+  class ZodType {
+    get description() {
+      return this._def.description;
+    }
+    _getType(input) {
+      return (0, util_js_1.getParsedType)(input.data);
+    }
+    _getOrReturnCtx(input, ctx) {
+      return ctx || {
+        common: input.parent.common,
+        data: input.data,
+        parsedType: (0, util_js_1.getParsedType)(input.data),
+        schemaErrorMap: this._def.errorMap,
+        path: input.path,
+        parent: input.parent
+      };
+    }
+    _processInputParams(input) {
+      return {
+        status: new parseUtil_js_1.ParseStatus,
+        ctx: {
+          common: input.parent.common,
+          data: input.data,
+          parsedType: (0, util_js_1.getParsedType)(input.data),
+          schemaErrorMap: this._def.errorMap,
+          path: input.path,
+          parent: input.parent
+        }
+      };
+    }
+    _parseSync(input) {
+      const result = this._parse(input);
+      if ((0, parseUtil_js_1.isAsync)(result)) {
+        throw new Error("Synchronous parse encountered promise.");
+      }
+      return result;
+    }
+    _parseAsync(input) {
+      const result = this._parse(input);
+      return Promise.resolve(result);
+    }
+    parse(data, params) {
+      const result = this.safeParse(data, params);
+      if (result.success)
+        return result.data;
+      throw result.error;
+    }
+    safeParse(data, params) {
+      const ctx = {
+        common: {
+          issues: [],
+          async: params?.async ?? false,
+          contextualErrorMap: params?.errorMap
+        },
+        path: params?.path || [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data,
+        parsedType: (0, util_js_1.getParsedType)(data)
+      };
+      const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+      return handleResult(ctx, result);
+    }
+    "~validate"(data) {
+      const ctx = {
+        common: {
+          issues: [],
+          async: !!this["~standard"].async
+        },
+        path: [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data,
+        parsedType: (0, util_js_1.getParsedType)(data)
+      };
+      if (!this["~standard"].async) {
+        try {
+          const result = this._parseSync({ data, path: [], parent: ctx });
+          return (0, parseUtil_js_1.isValid)(result) ? {
+            value: result.value
+          } : {
+            issues: ctx.common.issues
+          };
+        } catch (err) {
+          if (err?.message?.toLowerCase()?.includes("encountered")) {
+            this["~standard"].async = true;
+          }
+          ctx.common = {
+            issues: [],
+            async: true
+          };
+        }
+      }
+      return this._parseAsync({ data, path: [], parent: ctx }).then((result) => (0, parseUtil_js_1.isValid)(result) ? {
+        value: result.value
+      } : {
+        issues: ctx.common.issues
+      });
+    }
+    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?.errorMap,
+          async: true
+        },
+        path: params?.path || [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data,
+        parsedType: (0, util_js_1.getParsedType)(data)
+      };
+      const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
+      const result = await ((0, parseUtil_js_1.isAsync)(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+      return handleResult(ctx, result);
+    }
+    refine(check, message) {
+      const getIssueProperties = (val) => {
+        if (typeof message === "string" || typeof message === "undefined") {
+          return { message };
+        } else if (typeof message === "function") {
+          return message(val);
+        } else {
+          return message;
+        }
+      };
+      return this._refinement((val, ctx) => {
+        const result = check(val);
+        const setError = () => ctx.addIssue({
+          code: ZodError_js_1.ZodIssueCode.custom,
+          ...getIssueProperties(val)
+        });
+        if (typeof Promise !== "undefined" && result instanceof Promise) {
+          return result.then((data) => {
+            if (!data) {
+              setError();
+              return false;
+            } else {
+              return true;
+            }
+          });
+        }
+        if (!result) {
+          setError();
+          return false;
+        } else {
+          return true;
+        }
+      });
+    }
+    refinement(check, refinementData) {
+      return this._refinement((val, ctx) => {
+        if (!check(val)) {
+          ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+          return false;
+        } else {
+          return true;
+        }
+      });
+    }
+    _refinement(refinement) {
+      return new ZodEffects({
+        schema: this,
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        effect: { type: "refinement", refinement }
+      });
+    }
+    superRefine(refinement) {
+      return this._refinement(refinement);
+    }
+    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.readonly = this.readonly.bind(this);
+      this.isNullable = this.isNullable.bind(this);
+      this.isOptional = this.isOptional.bind(this);
+      this["~standard"] = {
+        version: 1,
+        vendor: "zod",
+        validate: (data) => this["~validate"](data)
+      };
+    }
+    optional() {
+      return ZodOptional.create(this, this._def);
+    }
+    nullable() {
+      return ZodNullable.create(this, this._def);
+    }
+    nullish() {
+      return this.nullable().optional();
+    }
+    array() {
+      return ZodArray.create(this);
+    }
+    promise() {
+      return ZodPromise.create(this, this._def);
+    }
+    or(option) {
+      return ZodUnion.create([this, option], this._def);
+    }
+    and(incoming) {
+      return ZodIntersection.create(this, incoming, this._def);
+    }
+    transform(transform) {
+      return new ZodEffects({
+        ...processCreateParams(this._def),
+        schema: this,
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        effect: { type: "transform", transform }
+      });
+    }
+    default(def) {
+      const defaultValueFunc = typeof def === "function" ? def : () => def;
+      return new ZodDefault({
+        ...processCreateParams(this._def),
+        innerType: this,
+        defaultValue: defaultValueFunc,
+        typeName: ZodFirstPartyTypeKind.ZodDefault
+      });
+    }
+    brand() {
+      return new ZodBranded({
+        typeName: ZodFirstPartyTypeKind.ZodBranded,
+        type: this,
+        ...processCreateParams(this._def)
+      });
+    }
+    catch(def) {
+      const catchValueFunc = typeof def === "function" ? def : () => def;
+      return new ZodCatch({
+        ...processCreateParams(this._def),
+        innerType: this,
+        catchValue: catchValueFunc,
+        typeName: ZodFirstPartyTypeKind.ZodCatch
+      });
+    }
+    describe(description) {
+      const This = this.constructor;
+      return new This({
+        ...this._def,
+        description
+      });
+    }
+    pipe(target) {
+      return ZodPipeline.create(this, target);
+    }
+    readonly() {
+      return ZodReadonly.create(this);
+    }
+    isOptional() {
+      return this.safeParse(undefined).success;
+    }
+    isNullable() {
+      return this.safeParse(null).success;
+    }
+  }
+  exports.ZodType = ZodType;
+  exports.Schema = ZodType;
+  exports.ZodSchema = ZodType;
+  var cuidRegex = /^c[^\s-]{8,}$/i;
+  var cuid2Regex = /^[0-9a-z]+$/;
+  var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+  var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
+  var nanoidRegex = /^[a-z0-9_-]{21}$/i;
+  var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
+  var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
+  var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
+  var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+  var emojiRegex;
+  var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+  var ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
+  var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+  var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+  var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+  var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
+  var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
+  var dateRegex = new RegExp(`^${dateRegexSource}$`);
+  function timeRegexSource(args) {
+    let secondsRegexSource = `[0-5]\\d`;
+    if (args.precision) {
+      secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
+    } else if (args.precision == null) {
+      secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
+    }
+    const secondsQuantifier = args.precision ? "+" : "?";
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
+  }
+  function timeRegex(args) {
+    return new RegExp(`^${timeRegexSource(args)}$`);
+  }
+  function datetimeRegex(args) {
+    let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+    const opts = [];
+    opts.push(args.local ? `Z?` : `Z`);
+    if (args.offset)
+      opts.push(`([+-]\\d{2}:?\\d{2})`);
+    regex = `${regex}(${opts.join("|")})`;
+    return new RegExp(`^${regex}$`);
+  }
+  function isValidIP(ip, version) {
+    if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
+      return true;
+    }
+    if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
+      return true;
+    }
+    return false;
+  }
+  function isValidJWT(jwt, alg) {
+    if (!jwtRegex.test(jwt))
+      return false;
+    try {
+      const [header] = jwt.split(".");
+      if (!header)
+        return false;
+      const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
+      const decoded = JSON.parse(atob(base64));
+      if (typeof decoded !== "object" || decoded === null)
+        return false;
+      if ("typ" in decoded && decoded?.typ !== "JWT")
+        return false;
+      if (!decoded.alg)
+        return false;
+      if (alg && decoded.alg !== alg)
+        return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function isValidCidr(ip, version) {
+    if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
+      return true;
+    }
+    if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
+      return true;
+    }
+    return false;
+  }
+
+  class ZodString extends ZodType {
+    _parse(input) {
+      if (this._def.coerce) {
+        input.data = String(input.data);
+      }
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.string) {
+        const ctx2 = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx2, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.string,
+          received: ctx2.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const status = new parseUtil_js_1.ParseStatus;
+      let ctx = undefined;
+      for (const check of this._def.checks) {
+        if (check.kind === "min") {
+          if (input.data.length < check.value) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_small,
+              minimum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: false,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "max") {
+          if (input.data.length > check.value) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_big,
+              maximum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: false,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "length") {
+          const tooBig = input.data.length > check.value;
+          const tooSmall = input.data.length < check.value;
+          if (tooBig || tooSmall) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            if (tooBig) {
+              (0, parseUtil_js_1.addIssueToContext)(ctx, {
+                code: ZodError_js_1.ZodIssueCode.too_big,
+                maximum: check.value,
+                type: "string",
+                inclusive: true,
+                exact: true,
+                message: check.message
+              });
+            } else if (tooSmall) {
+              (0, parseUtil_js_1.addIssueToContext)(ctx, {
+                code: ZodError_js_1.ZodIssueCode.too_small,
+                minimum: check.value,
+                type: "string",
+                inclusive: true,
+                exact: true,
+                message: check.message
+              });
+            }
+            status.dirty();
+          }
+        } else if (check.kind === "email") {
+          if (!emailRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "email",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "emoji") {
+          if (!emojiRegex) {
+            emojiRegex = new RegExp(_emojiRegex, "u");
+          }
+          if (!emojiRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "emoji",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "uuid") {
+          if (!uuidRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "uuid",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "nanoid") {
+          if (!nanoidRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "nanoid",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "cuid") {
+          if (!cuidRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "cuid",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "cuid2") {
+          if (!cuid2Regex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "cuid2",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "ulid") {
+          if (!ulidRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "ulid",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "url") {
+          try {
+            new URL(input.data);
+          } catch {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "url",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "regex") {
+          check.regex.lastIndex = 0;
+          const testResult = check.regex.test(input.data);
+          if (!testResult) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "regex",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "trim") {
+          input.data = input.data.trim();
+        } else if (check.kind === "includes") {
+          if (!input.data.includes(check.value, check.position)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: { includes: check.value, position: check.position },
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "toLowerCase") {
+          input.data = input.data.toLowerCase();
+        } else if (check.kind === "toUpperCase") {
+          input.data = input.data.toUpperCase();
+        } else if (check.kind === "startsWith") {
+          if (!input.data.startsWith(check.value)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: { startsWith: check.value },
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "endsWith") {
+          if (!input.data.endsWith(check.value)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: { endsWith: check.value },
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "datetime") {
+          const regex = datetimeRegex(check);
+          if (!regex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: "datetime",
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "date") {
+          const regex = dateRegex;
+          if (!regex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: "date",
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "time") {
+          const regex = timeRegex(check);
+          if (!regex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              validation: "time",
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "duration") {
+          if (!durationRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "duration",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "ip") {
+          if (!isValidIP(input.data, check.version)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "ip",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "jwt") {
+          if (!isValidJWT(input.data, check.alg)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "jwt",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "cidr") {
+          if (!isValidCidr(input.data, check.version)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "cidr",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "base64") {
+          if (!base64Regex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "base64",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "base64url") {
+          if (!base64urlRegex.test(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              validation: "base64url",
+              code: ZodError_js_1.ZodIssueCode.invalid_string,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else {
+          util_js_1.util.assertNever(check);
+        }
+      }
+      return { status: status.value, value: input.data };
+    }
+    _regex(regex, validation, message) {
+      return this.refinement((data) => regex.test(data), {
+        validation,
+        code: ZodError_js_1.ZodIssueCode.invalid_string,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    _addCheck(check) {
+      return new ZodString({
+        ...this._def,
+        checks: [...this._def.checks, check]
+      });
+    }
+    email(message) {
+      return this._addCheck({ kind: "email", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    url(message) {
+      return this._addCheck({ kind: "url", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    emoji(message) {
+      return this._addCheck({ kind: "emoji", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    uuid(message) {
+      return this._addCheck({ kind: "uuid", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    nanoid(message) {
+      return this._addCheck({ kind: "nanoid", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    cuid(message) {
+      return this._addCheck({ kind: "cuid", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    cuid2(message) {
+      return this._addCheck({ kind: "cuid2", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    ulid(message) {
+      return this._addCheck({ kind: "ulid", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    base64(message) {
+      return this._addCheck({ kind: "base64", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    base64url(message) {
+      return this._addCheck({
+        kind: "base64url",
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    jwt(options) {
+      return this._addCheck({ kind: "jwt", ...errorUtil_js_1.errorUtil.errToObj(options) });
+    }
+    ip(options) {
+      return this._addCheck({ kind: "ip", ...errorUtil_js_1.errorUtil.errToObj(options) });
+    }
+    cidr(options) {
+      return this._addCheck({ kind: "cidr", ...errorUtil_js_1.errorUtil.errToObj(options) });
+    }
+    datetime(options) {
+      if (typeof options === "string") {
+        return this._addCheck({
+          kind: "datetime",
+          precision: null,
+          offset: false,
+          local: false,
+          message: options
+        });
+      }
+      return this._addCheck({
+        kind: "datetime",
+        precision: typeof options?.precision === "undefined" ? null : options?.precision,
+        offset: options?.offset ?? false,
+        local: options?.local ?? false,
+        ...errorUtil_js_1.errorUtil.errToObj(options?.message)
+      });
+    }
+    date(message) {
+      return this._addCheck({ kind: "date", message });
+    }
+    time(options) {
+      if (typeof options === "string") {
+        return this._addCheck({
+          kind: "time",
+          precision: null,
+          message: options
+        });
+      }
+      return this._addCheck({
+        kind: "time",
+        precision: typeof options?.precision === "undefined" ? null : options?.precision,
+        ...errorUtil_js_1.errorUtil.errToObj(options?.message)
+      });
+    }
+    duration(message) {
+      return this._addCheck({ kind: "duration", ...errorUtil_js_1.errorUtil.errToObj(message) });
+    }
+    regex(regex, message) {
+      return this._addCheck({
+        kind: "regex",
+        regex,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    includes(value, options) {
+      return this._addCheck({
+        kind: "includes",
+        value,
+        position: options?.position,
+        ...errorUtil_js_1.errorUtil.errToObj(options?.message)
+      });
+    }
+    startsWith(value, message) {
+      return this._addCheck({
+        kind: "startsWith",
+        value,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    endsWith(value, message) {
+      return this._addCheck({
+        kind: "endsWith",
+        value,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    min(minLength, message) {
+      return this._addCheck({
+        kind: "min",
+        value: minLength,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    max(maxLength, message) {
+      return this._addCheck({
+        kind: "max",
+        value: maxLength,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    length(len, message) {
+      return this._addCheck({
+        kind: "length",
+        value: len,
+        ...errorUtil_js_1.errorUtil.errToObj(message)
+      });
+    }
+    nonempty(message) {
+      return this.min(1, errorUtil_js_1.errorUtil.errToObj(message));
+    }
+    trim() {
+      return new ZodString({
+        ...this._def,
+        checks: [...this._def.checks, { kind: "trim" }]
+      });
+    }
+    toLowerCase() {
+      return new ZodString({
+        ...this._def,
+        checks: [...this._def.checks, { kind: "toLowerCase" }]
+      });
+    }
+    toUpperCase() {
+      return new ZodString({
+        ...this._def,
+        checks: [...this._def.checks, { kind: "toUpperCase" }]
+      });
+    }
+    get isDatetime() {
+      return !!this._def.checks.find((ch) => ch.kind === "datetime");
+    }
+    get isDate() {
+      return !!this._def.checks.find((ch) => ch.kind === "date");
+    }
+    get isTime() {
+      return !!this._def.checks.find((ch) => ch.kind === "time");
+    }
+    get isDuration() {
+      return !!this._def.checks.find((ch) => ch.kind === "duration");
+    }
+    get isEmail() {
+      return !!this._def.checks.find((ch) => ch.kind === "email");
+    }
+    get isURL() {
+      return !!this._def.checks.find((ch) => ch.kind === "url");
+    }
+    get isEmoji() {
+      return !!this._def.checks.find((ch) => ch.kind === "emoji");
+    }
+    get isUUID() {
+      return !!this._def.checks.find((ch) => ch.kind === "uuid");
+    }
+    get isNANOID() {
+      return !!this._def.checks.find((ch) => ch.kind === "nanoid");
+    }
+    get isCUID() {
+      return !!this._def.checks.find((ch) => ch.kind === "cuid");
+    }
+    get isCUID2() {
+      return !!this._def.checks.find((ch) => ch.kind === "cuid2");
+    }
+    get isULID() {
+      return !!this._def.checks.find((ch) => ch.kind === "ulid");
+    }
+    get isIP() {
+      return !!this._def.checks.find((ch) => ch.kind === "ip");
+    }
+    get isCIDR() {
+      return !!this._def.checks.find((ch) => ch.kind === "cidr");
+    }
+    get isBase64() {
+      return !!this._def.checks.find((ch) => ch.kind === "base64");
+    }
+    get isBase64url() {
+      return !!this._def.checks.find((ch) => ch.kind === "base64url");
+    }
+    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;
+    }
+  }
+  exports.ZodString = ZodString;
+  ZodString.create = (params) => {
+    return new ZodString({
+      checks: [],
+      typeName: ZodFirstPartyTypeKind.ZodString,
+      coerce: params?.coerce ?? false,
+      ...processCreateParams(params)
+    });
+  };
+  function floatSafeRemainder(val, step) {
+    const valDecCount = (val.toString().split(".")[1] || "").length;
+    const stepDecCount = (step.toString().split(".")[1] || "").length;
+    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+    return valInt % stepInt / 10 ** decCount;
+  }
+
+  class ZodNumber extends ZodType {
+    constructor() {
+      super(...arguments);
+      this.min = this.gte;
+      this.max = this.lte;
+      this.step = this.multipleOf;
+    }
+    _parse(input) {
+      if (this._def.coerce) {
+        input.data = Number(input.data);
+      }
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.number) {
+        const ctx2 = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx2, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.number,
+          received: ctx2.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      let ctx = undefined;
+      const status = new parseUtil_js_1.ParseStatus;
+      for (const check of this._def.checks) {
+        if (check.kind === "int") {
+          if (!util_js_1.util.isInteger(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.invalid_type,
+              expected: "integer",
+              received: "float",
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "min") {
+          const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+          if (tooSmall) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_small,
+              minimum: check.value,
+              type: "number",
+              inclusive: check.inclusive,
+              exact: false,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "max") {
+          const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+          if (tooBig) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_big,
+              maximum: check.value,
+              type: "number",
+              inclusive: check.inclusive,
+              exact: false,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "multipleOf") {
+          if (floatSafeRemainder(input.data, check.value) !== 0) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.not_multiple_of,
+              multipleOf: check.value,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "finite") {
+          if (!Number.isFinite(input.data)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.not_finite,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else {
+          util_js_1.util.assertNever(check);
+        }
+      }
+      return { status: status.value, value: input.data };
+    }
+    gte(value, message) {
+      return this.setLimit("min", value, true, errorUtil_js_1.errorUtil.toString(message));
+    }
+    gt(value, message) {
+      return this.setLimit("min", value, false, errorUtil_js_1.errorUtil.toString(message));
+    }
+    lte(value, message) {
+      return this.setLimit("max", value, true, errorUtil_js_1.errorUtil.toString(message));
+    }
+    lt(value, message) {
+      return this.setLimit("max", value, false, errorUtil_js_1.errorUtil.toString(message));
+    }
+    setLimit(kind, value, inclusive, message) {
+      return new ZodNumber({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind,
+            value,
+            inclusive,
+            message: errorUtil_js_1.errorUtil.toString(message)
+          }
+        ]
+      });
+    }
+    _addCheck(check) {
+      return new ZodNumber({
+        ...this._def,
+        checks: [...this._def.checks, check]
+      });
+    }
+    int(message) {
+      return this._addCheck({
+        kind: "int",
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    positive(message) {
+      return this._addCheck({
+        kind: "min",
+        value: 0,
+        inclusive: false,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    negative(message) {
+      return this._addCheck({
+        kind: "max",
+        value: 0,
+        inclusive: false,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    nonpositive(message) {
+      return this._addCheck({
+        kind: "max",
+        value: 0,
+        inclusive: true,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    nonnegative(message) {
+      return this._addCheck({
+        kind: "min",
+        value: 0,
+        inclusive: true,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    multipleOf(value, message) {
+      return this._addCheck({
+        kind: "multipleOf",
+        value,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    finite(message) {
+      return this._addCheck({
+        kind: "finite",
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    safe(message) {
+      return this._addCheck({
+        kind: "min",
+        inclusive: true,
+        value: Number.MIN_SAFE_INTEGER,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      })._addCheck({
+        kind: "max",
+        inclusive: true,
+        value: Number.MAX_SAFE_INTEGER,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    get minValue() {
+      let min = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "min") {
+          if (min === null || ch.value > min)
+            min = ch.value;
+        }
+      }
+      return min;
+    }
+    get maxValue() {
+      let max = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "max") {
+          if (max === null || ch.value < max)
+            max = ch.value;
+        }
+      }
+      return max;
+    }
+    get isInt() {
+      return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util_js_1.util.isInteger(ch.value));
+    }
+    get isFinite() {
+      let max = null;
+      let min = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
+          return true;
+        } else if (ch.kind === "min") {
+          if (min === null || ch.value > min)
+            min = ch.value;
+        } else if (ch.kind === "max") {
+          if (max === null || ch.value < max)
+            max = ch.value;
+        }
+      }
+      return Number.isFinite(min) && Number.isFinite(max);
+    }
+  }
+  exports.ZodNumber = ZodNumber;
+  ZodNumber.create = (params) => {
+    return new ZodNumber({
+      checks: [],
+      typeName: ZodFirstPartyTypeKind.ZodNumber,
+      coerce: params?.coerce || false,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodBigInt extends ZodType {
+    constructor() {
+      super(...arguments);
+      this.min = this.gte;
+      this.max = this.lte;
+    }
+    _parse(input) {
+      if (this._def.coerce) {
+        try {
+          input.data = BigInt(input.data);
+        } catch {
+          return this._getInvalidInput(input);
+        }
+      }
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.bigint) {
+        return this._getInvalidInput(input);
+      }
+      let ctx = undefined;
+      const status = new parseUtil_js_1.ParseStatus;
+      for (const check of this._def.checks) {
+        if (check.kind === "min") {
+          const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+          if (tooSmall) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_small,
+              type: "bigint",
+              minimum: check.value,
+              inclusive: check.inclusive,
+              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);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_big,
+              type: "bigint",
+              maximum: check.value,
+              inclusive: check.inclusive,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "multipleOf") {
+          if (input.data % check.value !== BigInt(0)) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.not_multiple_of,
+              multipleOf: check.value,
+              message: check.message
+            });
+            status.dirty();
+          }
+        } else {
+          util_js_1.util.assertNever(check);
+        }
+      }
+      return { status: status.value, value: input.data };
+    }
+    _getInvalidInput(input) {
+      const ctx = this._getOrReturnCtx(input);
+      (0, parseUtil_js_1.addIssueToContext)(ctx, {
+        code: ZodError_js_1.ZodIssueCode.invalid_type,
+        expected: util_js_1.ZodParsedType.bigint,
+        received: ctx.parsedType
+      });
+      return parseUtil_js_1.INVALID;
+    }
+    gte(value, message) {
+      return this.setLimit("min", value, true, errorUtil_js_1.errorUtil.toString(message));
+    }
+    gt(value, message) {
+      return this.setLimit("min", value, false, errorUtil_js_1.errorUtil.toString(message));
+    }
+    lte(value, message) {
+      return this.setLimit("max", value, true, errorUtil_js_1.errorUtil.toString(message));
+    }
+    lt(value, message) {
+      return this.setLimit("max", value, false, errorUtil_js_1.errorUtil.toString(message));
+    }
+    setLimit(kind, value, inclusive, message) {
+      return new ZodBigInt({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind,
+            value,
+            inclusive,
+            message: errorUtil_js_1.errorUtil.toString(message)
+          }
+        ]
+      });
+    }
+    _addCheck(check) {
+      return new ZodBigInt({
+        ...this._def,
+        checks: [...this._def.checks, check]
+      });
+    }
+    positive(message) {
+      return this._addCheck({
+        kind: "min",
+        value: BigInt(0),
+        inclusive: false,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    negative(message) {
+      return this._addCheck({
+        kind: "max",
+        value: BigInt(0),
+        inclusive: false,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    nonpositive(message) {
+      return this._addCheck({
+        kind: "max",
+        value: BigInt(0),
+        inclusive: true,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    nonnegative(message) {
+      return this._addCheck({
+        kind: "min",
+        value: BigInt(0),
+        inclusive: true,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    multipleOf(value, message) {
+      return this._addCheck({
+        kind: "multipleOf",
+        value,
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    get minValue() {
+      let min = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "min") {
+          if (min === null || ch.value > min)
+            min = ch.value;
+        }
+      }
+      return min;
+    }
+    get maxValue() {
+      let max = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "max") {
+          if (max === null || ch.value < max)
+            max = ch.value;
+        }
+      }
+      return max;
+    }
+  }
+  exports.ZodBigInt = ZodBigInt;
+  ZodBigInt.create = (params) => {
+    return new ZodBigInt({
+      checks: [],
+      typeName: ZodFirstPartyTypeKind.ZodBigInt,
+      coerce: params?.coerce ?? false,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodBoolean extends ZodType {
+    _parse(input) {
+      if (this._def.coerce) {
+        input.data = Boolean(input.data);
+      }
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.boolean) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.boolean,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodBoolean = ZodBoolean;
+  ZodBoolean.create = (params) => {
+    return new ZodBoolean({
+      typeName: ZodFirstPartyTypeKind.ZodBoolean,
+      coerce: params?.coerce || false,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodDate extends ZodType {
+    _parse(input) {
+      if (this._def.coerce) {
+        input.data = new Date(input.data);
+      }
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.date) {
+        const ctx2 = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx2, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.date,
+          received: ctx2.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (Number.isNaN(input.data.getTime())) {
+        const ctx2 = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx2, {
+          code: ZodError_js_1.ZodIssueCode.invalid_date
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const status = new parseUtil_js_1.ParseStatus;
+      let ctx = undefined;
+      for (const check of this._def.checks) {
+        if (check.kind === "min") {
+          if (input.data.getTime() < check.value) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_small,
+              message: check.message,
+              inclusive: true,
+              exact: false,
+              minimum: check.value,
+              type: "date"
+            });
+            status.dirty();
+          }
+        } else if (check.kind === "max") {
+          if (input.data.getTime() > check.value) {
+            ctx = this._getOrReturnCtx(input, ctx);
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.too_big,
+              message: check.message,
+              inclusive: true,
+              exact: false,
+              maximum: check.value,
+              type: "date"
+            });
+            status.dirty();
+          }
+        } else {
+          util_js_1.util.assertNever(check);
+        }
+      }
+      return {
+        status: status.value,
+        value: new Date(input.data.getTime())
+      };
+    }
+    _addCheck(check) {
+      return new ZodDate({
+        ...this._def,
+        checks: [...this._def.checks, check]
+      });
+    }
+    min(minDate, message) {
+      return this._addCheck({
+        kind: "min",
+        value: minDate.getTime(),
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    max(maxDate, message) {
+      return this._addCheck({
+        kind: "max",
+        value: maxDate.getTime(),
+        message: errorUtil_js_1.errorUtil.toString(message)
+      });
+    }
+    get minDate() {
+      let min = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "min") {
+          if (min === null || ch.value > min)
+            min = ch.value;
+        }
+      }
+      return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+      let max = null;
+      for (const ch of this._def.checks) {
+        if (ch.kind === "max") {
+          if (max === null || ch.value < max)
+            max = ch.value;
+        }
+      }
+      return max != null ? new Date(max) : null;
+    }
+  }
+  exports.ZodDate = ZodDate;
+  ZodDate.create = (params) => {
+    return new ZodDate({
+      checks: [],
+      coerce: params?.coerce || false,
+      typeName: ZodFirstPartyTypeKind.ZodDate,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodSymbol extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.symbol) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.symbol,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodSymbol = ZodSymbol;
+  ZodSymbol.create = (params) => {
+    return new ZodSymbol({
+      typeName: ZodFirstPartyTypeKind.ZodSymbol,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodUndefined extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.undefined) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.undefined,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodUndefined = ZodUndefined;
+  ZodUndefined.create = (params) => {
+    return new ZodUndefined({
+      typeName: ZodFirstPartyTypeKind.ZodUndefined,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodNull extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.null) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.null,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodNull = ZodNull;
+  ZodNull.create = (params) => {
+    return new ZodNull({
+      typeName: ZodFirstPartyTypeKind.ZodNull,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodAny extends ZodType {
+    constructor() {
+      super(...arguments);
+      this._any = true;
+    }
+    _parse(input) {
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodAny = ZodAny;
+  ZodAny.create = (params) => {
+    return new ZodAny({
+      typeName: ZodFirstPartyTypeKind.ZodAny,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodUnknown extends ZodType {
+    constructor() {
+      super(...arguments);
+      this._unknown = true;
+    }
+    _parse(input) {
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodUnknown = ZodUnknown;
+  ZodUnknown.create = (params) => {
+    return new ZodUnknown({
+      typeName: ZodFirstPartyTypeKind.ZodUnknown,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodNever extends ZodType {
+    _parse(input) {
+      const ctx = this._getOrReturnCtx(input);
+      (0, parseUtil_js_1.addIssueToContext)(ctx, {
+        code: ZodError_js_1.ZodIssueCode.invalid_type,
+        expected: util_js_1.ZodParsedType.never,
+        received: ctx.parsedType
+      });
+      return parseUtil_js_1.INVALID;
+    }
+  }
+  exports.ZodNever = ZodNever;
+  ZodNever.create = (params) => {
+    return new ZodNever({
+      typeName: ZodFirstPartyTypeKind.ZodNever,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodVoid extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.undefined) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.void,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+  }
+  exports.ZodVoid = ZodVoid;
+  ZodVoid.create = (params) => {
+    return new ZodVoid({
+      typeName: ZodFirstPartyTypeKind.ZodVoid,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodArray extends ZodType {
+    _parse(input) {
+      const { ctx, status } = this._processInputParams(input);
+      const def = this._def;
+      if (ctx.parsedType !== util_js_1.ZodParsedType.array) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.array,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (def.exactLength !== null) {
+        const tooBig = ctx.data.length > def.exactLength.value;
+        const tooSmall = ctx.data.length < def.exactLength.value;
+        if (tooBig || tooSmall) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: tooBig ? ZodError_js_1.ZodIssueCode.too_big : ZodError_js_1.ZodIssueCode.too_small,
+            minimum: tooSmall ? def.exactLength.value : undefined,
+            maximum: tooBig ? def.exactLength.value : undefined,
+            type: "array",
+            inclusive: true,
+            exact: true,
+            message: def.exactLength.message
+          });
+          status.dirty();
+        }
+      }
+      if (def.minLength !== null) {
+        if (ctx.data.length < def.minLength.value) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: ZodError_js_1.ZodIssueCode.too_small,
+            minimum: def.minLength.value,
+            type: "array",
+            inclusive: true,
+            exact: false,
+            message: def.minLength.message
+          });
+          status.dirty();
+        }
+      }
+      if (def.maxLength !== null) {
+        if (ctx.data.length > def.maxLength.value) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: ZodError_js_1.ZodIssueCode.too_big,
+            maximum: def.maxLength.value,
+            type: "array",
+            inclusive: true,
+            exact: false,
+            message: def.maxLength.message
+          });
+          status.dirty();
+        }
+      }
+      if (ctx.common.async) {
+        return Promise.all([...ctx.data].map((item, i) => {
+          return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+        })).then((result2) => {
+          return parseUtil_js_1.ParseStatus.mergeArray(status, result2);
+        });
+      }
+      const result = [...ctx.data].map((item, i) => {
+        return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+      });
+      return parseUtil_js_1.ParseStatus.mergeArray(status, result);
+    }
+    get element() {
+      return this._def.type;
+    }
+    min(minLength, message) {
+      return new ZodArray({
+        ...this._def,
+        minLength: { value: minLength, message: errorUtil_js_1.errorUtil.toString(message) }
+      });
+    }
+    max(maxLength, message) {
+      return new ZodArray({
+        ...this._def,
+        maxLength: { value: maxLength, message: errorUtil_js_1.errorUtil.toString(message) }
+      });
+    }
+    length(len, message) {
+      return new ZodArray({
+        ...this._def,
+        exactLength: { value: len, message: errorUtil_js_1.errorUtil.toString(message) }
+      });
+    }
+    nonempty(message) {
+      return this.min(1, message);
+    }
+  }
+  exports.ZodArray = ZodArray;
+  ZodArray.create = (schema, params) => {
+    return new ZodArray({
+      type: schema,
+      minLength: null,
+      maxLength: null,
+      exactLength: null,
+      typeName: ZodFirstPartyTypeKind.ZodArray,
+      ...processCreateParams(params)
+    });
+  };
+  function deepPartialify(schema) {
+    if (schema instanceof ZodObject) {
+      const newShape = {};
+      for (const key in schema.shape) {
+        const fieldSchema = schema.shape[key];
+        newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
+      }
+      return new ZodObject({
+        ...schema._def,
+        shape: () => newShape
+      });
+    } else if (schema instanceof ZodArray) {
+      return new ZodArray({
+        ...schema._def,
+        type: deepPartialify(schema.element)
+      });
+    } else if (schema instanceof ZodOptional) {
+      return ZodOptional.create(deepPartialify(schema.unwrap()));
+    } else if (schema instanceof ZodNullable) {
+      return ZodNullable.create(deepPartialify(schema.unwrap()));
+    } else if (schema instanceof ZodTuple) {
+      return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+    } else {
+      return schema;
+    }
+  }
+
+  class ZodObject extends ZodType {
+    constructor() {
+      super(...arguments);
+      this._cached = null;
+      this.nonstrict = this.passthrough;
+      this.augment = this.extend;
+    }
+    _getCached() {
+      if (this._cached !== null)
+        return this._cached;
+      const shape = this._def.shape();
+      const keys = util_js_1.util.objectKeys(shape);
+      this._cached = { shape, keys };
+      return this._cached;
+    }
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.object) {
+        const ctx2 = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx2, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.object,
+          received: ctx2.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const { status, ctx } = this._processInputParams(input);
+      const { shape, keys: shapeKeys } = this._getCached();
+      const extraKeys = [];
+      if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
+        for (const key in ctx.data) {
+          if (!shapeKeys.includes(key)) {
+            extraKeys.push(key);
+          }
+        }
+      }
+      const pairs = [];
+      for (const key of shapeKeys) {
+        const keyValidator = shape[key];
+        const value = ctx.data[key];
+        pairs.push({
+          key: { status: "valid", value: key },
+          value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+          alwaysSet: key in ctx.data
+        });
+      }
+      if (this._def.catchall instanceof ZodNever) {
+        const unknownKeys = this._def.unknownKeys;
+        if (unknownKeys === "passthrough") {
+          for (const key of extraKeys) {
+            pairs.push({
+              key: { status: "valid", value: key },
+              value: { status: "valid", value: ctx.data[key] }
+            });
+          }
+        } else if (unknownKeys === "strict") {
+          if (extraKeys.length > 0) {
+            (0, parseUtil_js_1.addIssueToContext)(ctx, {
+              code: ZodError_js_1.ZodIssueCode.unrecognized_keys,
+              keys: extraKeys
+            });
+            status.dirty();
+          }
+        } else if (unknownKeys === "strip") {} else {
+          throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
+        }
+      } else {
+        const catchall = this._def.catchall;
+        for (const key of extraKeys) {
+          const value = ctx.data[key];
+          pairs.push({
+            key: { status: "valid", value: key },
+            value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+            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;
+            const value = await pair.value;
+            syncPairs.push({
+              key,
+              value,
+              alwaysSet: pair.alwaysSet
+            });
+          }
+          return syncPairs;
+        }).then((syncPairs) => {
+          return parseUtil_js_1.ParseStatus.mergeObjectSync(status, syncPairs);
+        });
+      } else {
+        return parseUtil_js_1.ParseStatus.mergeObjectSync(status, pairs);
+      }
+    }
+    get shape() {
+      return this._def.shape();
+    }
+    strict(message) {
+      errorUtil_js_1.errorUtil.errToObj;
+      return new ZodObject({
+        ...this._def,
+        unknownKeys: "strict",
+        ...message !== undefined ? {
+          errorMap: (issue, ctx) => {
+            const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
+            if (issue.code === "unrecognized_keys")
+              return {
+                message: errorUtil_js_1.errorUtil.errToObj(message).message ?? defaultError
+              };
+            return {
+              message: defaultError
+            };
+          }
+        } : {}
+      });
+    }
+    strip() {
+      return new ZodObject({
+        ...this._def,
+        unknownKeys: "strip"
+      });
+    }
+    passthrough() {
+      return new ZodObject({
+        ...this._def,
+        unknownKeys: "passthrough"
+      });
+    }
+    extend(augmentation) {
+      return new ZodObject({
+        ...this._def,
+        shape: () => ({
+          ...this._def.shape(),
+          ...augmentation
+        })
+      });
+    }
+    merge(merging) {
+      const merged = new ZodObject({
+        unknownKeys: merging._def.unknownKeys,
+        catchall: merging._def.catchall,
+        shape: () => ({
+          ...this._def.shape(),
+          ...merging._def.shape()
+        }),
+        typeName: ZodFirstPartyTypeKind.ZodObject
+      });
+      return merged;
+    }
+    setKey(key, schema) {
+      return this.augment({ [key]: schema });
+    }
+    catchall(index) {
+      return new ZodObject({
+        ...this._def,
+        catchall: index
+      });
+    }
+    pick(mask) {
+      const shape = {};
+      for (const key of util_js_1.util.objectKeys(mask)) {
+        if (mask[key] && this.shape[key]) {
+          shape[key] = this.shape[key];
+        }
+      }
+      return new ZodObject({
+        ...this._def,
+        shape: () => shape
+      });
+    }
+    omit(mask) {
+      const shape = {};
+      for (const key of util_js_1.util.objectKeys(this.shape)) {
+        if (!mask[key]) {
+          shape[key] = this.shape[key];
+        }
+      }
+      return new ZodObject({
+        ...this._def,
+        shape: () => shape
+      });
+    }
+    deepPartial() {
+      return deepPartialify(this);
+    }
+    partial(mask) {
+      const newShape = {};
+      for (const key of util_js_1.util.objectKeys(this.shape)) {
+        const fieldSchema = this.shape[key];
+        if (mask && !mask[key]) {
+          newShape[key] = fieldSchema;
+        } else {
+          newShape[key] = fieldSchema.optional();
+        }
+      }
+      return new ZodObject({
+        ...this._def,
+        shape: () => newShape
+      });
+    }
+    required(mask) {
+      const newShape = {};
+      for (const key of util_js_1.util.objectKeys(this.shape)) {
+        if (mask && !mask[key]) {
+          newShape[key] = this.shape[key];
+        } else {
+          const fieldSchema = this.shape[key];
+          let newField = fieldSchema;
+          while (newField instanceof ZodOptional) {
+            newField = newField._def.innerType;
+          }
+          newShape[key] = newField;
+        }
+      }
+      return new ZodObject({
+        ...this._def,
+        shape: () => newShape
+      });
+    }
+    keyof() {
+      return createZodEnum(util_js_1.util.objectKeys(this.shape));
+    }
+  }
+  exports.ZodObject = ZodObject;
+  ZodObject.create = (shape, params) => {
+    return new ZodObject({
+      shape: () => shape,
+      unknownKeys: "strip",
+      catchall: ZodNever.create(),
+      typeName: ZodFirstPartyTypeKind.ZodObject,
+      ...processCreateParams(params)
+    });
+  };
+  ZodObject.strictCreate = (shape, params) => {
+    return new ZodObject({
+      shape: () => shape,
+      unknownKeys: "strict",
+      catchall: ZodNever.create(),
+      typeName: ZodFirstPartyTypeKind.ZodObject,
+      ...processCreateParams(params)
+    });
+  };
+  ZodObject.lazycreate = (shape, params) => {
+    return new ZodObject({
+      shape,
+      unknownKeys: "strip",
+      catchall: ZodNever.create(),
+      typeName: ZodFirstPartyTypeKind.ZodObject,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodUnion extends ZodType {
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      const options = this._def.options;
+      function handleResults(results) {
+        for (const result of results) {
+          if (result.result.status === "valid") {
+            return result.result;
+          }
+        }
+        for (const result of results) {
+          if (result.result.status === "dirty") {
+            ctx.common.issues.push(...result.ctx.common.issues);
+            return result.result;
+          }
+        }
+        const unionErrors = results.map((result) => new ZodError_js_1.ZodError(result.ctx.common.issues));
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_union,
+          unionErrors
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (ctx.common.async) {
+        return Promise.all(options.map(async (option) => {
+          const childCtx = {
+            ...ctx,
+            common: {
+              ...ctx.common,
+              issues: []
+            },
+            parent: null
+          };
+          return {
+            result: await option._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: childCtx
+            }),
+            ctx: childCtx
+          };
+        })).then(handleResults);
+      } else {
+        let dirty = undefined;
+        const issues = [];
+        for (const option of options) {
+          const childCtx = {
+            ...ctx,
+            common: {
+              ...ctx.common,
+              issues: []
+            },
+            parent: null
+          };
+          const result = option._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: childCtx
+          });
+          if (result.status === "valid") {
+            return result;
+          } else if (result.status === "dirty" && !dirty) {
+            dirty = { result, ctx: childCtx };
+          }
+          if (childCtx.common.issues.length) {
+            issues.push(childCtx.common.issues);
+          }
+        }
+        if (dirty) {
+          ctx.common.issues.push(...dirty.ctx.common.issues);
+          return dirty.result;
+        }
+        const unionErrors = issues.map((issues2) => new ZodError_js_1.ZodError(issues2));
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_union,
+          unionErrors
+        });
+        return parseUtil_js_1.INVALID;
+      }
+    }
+    get options() {
+      return this._def.options;
+    }
+  }
+  exports.ZodUnion = ZodUnion;
+  ZodUnion.create = (types, params) => {
+    return new ZodUnion({
+      options: types,
+      typeName: ZodFirstPartyTypeKind.ZodUnion,
+      ...processCreateParams(params)
+    });
+  };
+  var getDiscriminator = (type) => {
+    if (type instanceof ZodLazy) {
+      return getDiscriminator(type.schema);
+    } else if (type instanceof ZodEffects) {
+      return getDiscriminator(type.innerType());
+    } else if (type instanceof ZodLiteral) {
+      return [type.value];
+    } else if (type instanceof ZodEnum) {
+      return type.options;
+    } else if (type instanceof ZodNativeEnum) {
+      return util_js_1.util.objectValues(type.enum);
+    } else if (type instanceof ZodDefault) {
+      return getDiscriminator(type._def.innerType);
+    } else if (type instanceof ZodUndefined) {
+      return [undefined];
+    } else if (type instanceof ZodNull) {
+      return [null];
+    } else if (type instanceof ZodOptional) {
+      return [undefined, ...getDiscriminator(type.unwrap())];
+    } else if (type instanceof ZodNullable) {
+      return [null, ...getDiscriminator(type.unwrap())];
+    } else if (type instanceof ZodBranded) {
+      return getDiscriminator(type.unwrap());
+    } else if (type instanceof ZodReadonly) {
+      return getDiscriminator(type.unwrap());
+    } else if (type instanceof ZodCatch) {
+      return getDiscriminator(type._def.innerType);
+    } else {
+      return [];
+    }
+  };
+
+  class ZodDiscriminatedUnion extends ZodType {
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.object) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.object,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const discriminator = this.discriminator;
+      const discriminatorValue = ctx.data[discriminator];
+      const option = this.optionsMap.get(discriminatorValue);
+      if (!option) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_union_discriminator,
+          options: Array.from(this.optionsMap.keys()),
+          path: [discriminator]
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (ctx.common.async) {
+        return option._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+      } else {
+        return option._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+    }
+    get discriminator() {
+      return this._def.discriminator;
+    }
+    get options() {
+      return this._def.options;
+    }
+    get optionsMap() {
+      return this._def.optionsMap;
+    }
+    static create(discriminator, options, params) {
+      const optionsMap = new Map;
+      for (const type of options) {
+        const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+        if (!discriminatorValues.length) {
+          throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
+        }
+        for (const value of discriminatorValues) {
+          if (optionsMap.has(value)) {
+            throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
+          }
+          optionsMap.set(value, type);
+        }
+      }
+      return new ZodDiscriminatedUnion({
+        typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+        discriminator,
+        options,
+        optionsMap,
+        ...processCreateParams(params)
+      });
+    }
+  }
+  exports.ZodDiscriminatedUnion = ZodDiscriminatedUnion;
+  function mergeValues(a, b) {
+    const aType = (0, util_js_1.getParsedType)(a);
+    const bType = (0, util_js_1.getParsedType)(b);
+    if (a === b) {
+      return { valid: true, data: a };
+    } else if (aType === util_js_1.ZodParsedType.object && bType === util_js_1.ZodParsedType.object) {
+      const bKeys = util_js_1.util.objectKeys(b);
+      const sharedKeys = util_js_1.util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+      const newObj = { ...a, ...b };
+      for (const key of sharedKeys) {
+        const sharedValue = mergeValues(a[key], b[key]);
+        if (!sharedValue.valid) {
+          return { valid: false };
+        }
+        newObj[key] = sharedValue.data;
+      }
+      return { valid: true, data: newObj };
+    } else if (aType === util_js_1.ZodParsedType.array && bType === util_js_1.ZodParsedType.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 = mergeValues(itemA, itemB);
+        if (!sharedValue.valid) {
+          return { valid: false };
+        }
+        newArray.push(sharedValue.data);
+      }
+      return { valid: true, data: newArray };
+    } else if (aType === util_js_1.ZodParsedType.date && bType === util_js_1.ZodParsedType.date && +a === +b) {
+      return { valid: true, data: a };
+    } else {
+      return { valid: false };
+    }
+  }
+
+  class ZodIntersection extends ZodType {
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      const handleParsed = (parsedLeft, parsedRight) => {
+        if ((0, parseUtil_js_1.isAborted)(parsedLeft) || (0, parseUtil_js_1.isAborted)(parsedRight)) {
+          return parseUtil_js_1.INVALID;
+        }
+        const merged = mergeValues(parsedLeft.value, parsedRight.value);
+        if (!merged.valid) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: ZodError_js_1.ZodIssueCode.invalid_intersection_types
+          });
+          return parseUtil_js_1.INVALID;
+        }
+        if ((0, parseUtil_js_1.isDirty)(parsedLeft) || (0, parseUtil_js_1.isDirty)(parsedRight)) {
+          status.dirty();
+        }
+        return { status: status.value, value: merged.data };
+      };
+      if (ctx.common.async) {
+        return Promise.all([
+          this._def.left._parseAsync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          }),
+          this._def.right._parseAsync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          })
+        ]).then(([left, right]) => handleParsed(left, right));
+      } else {
+        return handleParsed(this._def.left._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        }), this._def.right._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        }));
+      }
+    }
+  }
+  exports.ZodIntersection = ZodIntersection;
+  ZodIntersection.create = (left, right, params) => {
+    return new ZodIntersection({
+      left,
+      right,
+      typeName: ZodFirstPartyTypeKind.ZodIntersection,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodTuple extends ZodType {
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.array) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.array,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (ctx.data.length < this._def.items.length) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.too_small,
+          minimum: this._def.items.length,
+          inclusive: true,
+          exact: false,
+          type: "array"
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const rest = this._def.rest;
+      if (!rest && ctx.data.length > this._def.items.length) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.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 ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+      }).filter((x) => !!x);
+      if (ctx.common.async) {
+        return Promise.all(items).then((results) => {
+          return parseUtil_js_1.ParseStatus.mergeArray(status, results);
+        });
+      } else {
+        return parseUtil_js_1.ParseStatus.mergeArray(status, items);
+      }
+    }
+    get items() {
+      return this._def.items;
+    }
+    rest(rest) {
+      return new ZodTuple({
+        ...this._def,
+        rest
+      });
+    }
+  }
+  exports.ZodTuple = ZodTuple;
+  ZodTuple.create = (schemas, params) => {
+    if (!Array.isArray(schemas)) {
+      throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+    }
+    return new ZodTuple({
+      items: schemas,
+      typeName: ZodFirstPartyTypeKind.ZodTuple,
+      rest: null,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodRecord extends ZodType {
+    get keySchema() {
+      return this._def.keyType;
+    }
+    get valueSchema() {
+      return this._def.valueType;
+    }
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.object) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.object,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const pairs = [];
+      const keyType = this._def.keyType;
+      const valueType = this._def.valueType;
+      for (const key in ctx.data) {
+        pairs.push({
+          key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+          value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
+          alwaysSet: key in ctx.data
+        });
+      }
+      if (ctx.common.async) {
+        return parseUtil_js_1.ParseStatus.mergeObjectAsync(status, pairs);
+      } else {
+        return parseUtil_js_1.ParseStatus.mergeObjectSync(status, pairs);
+      }
+    }
+    get element() {
+      return this._def.valueType;
+    }
+    static create(first, second, third) {
+      if (second instanceof ZodType) {
+        return new ZodRecord({
+          keyType: first,
+          valueType: second,
+          typeName: ZodFirstPartyTypeKind.ZodRecord,
+          ...processCreateParams(third)
+        });
+      }
+      return new ZodRecord({
+        keyType: ZodString.create(),
+        valueType: first,
+        typeName: ZodFirstPartyTypeKind.ZodRecord,
+        ...processCreateParams(second)
+      });
+    }
+  }
+  exports.ZodRecord = ZodRecord;
+
+  class ZodMap extends ZodType {
+    get keySchema() {
+      return this._def.keyType;
+    }
+    get valueSchema() {
+      return this._def.valueType;
+    }
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.map) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.map,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const keyType = this._def.keyType;
+      const valueType = this._def.valueType;
+      const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+        return {
+          key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+          value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
+        };
+      });
+      if (ctx.common.async) {
+        const finalMap = 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 parseUtil_js_1.INVALID;
+            }
+            if (key.status === "dirty" || value.status === "dirty") {
+              status.dirty();
+            }
+            finalMap.set(key.value, value.value);
+          }
+          return { status: status.value, value: finalMap };
+        });
+      } else {
+        const finalMap = new Map;
+        for (const pair of pairs) {
+          const key = pair.key;
+          const value = pair.value;
+          if (key.status === "aborted" || value.status === "aborted") {
+            return parseUtil_js_1.INVALID;
+          }
+          if (key.status === "dirty" || value.status === "dirty") {
+            status.dirty();
+          }
+          finalMap.set(key.value, value.value);
+        }
+        return { status: status.value, value: finalMap };
+      }
+    }
+  }
+  exports.ZodMap = ZodMap;
+  ZodMap.create = (keyType, valueType, params) => {
+    return new ZodMap({
+      valueType,
+      keyType,
+      typeName: ZodFirstPartyTypeKind.ZodMap,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodSet extends ZodType {
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.set) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.set,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const def = this._def;
+      if (def.minSize !== null) {
+        if (ctx.data.size < def.minSize.value) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: ZodError_js_1.ZodIssueCode.too_small,
+            minimum: def.minSize.value,
+            type: "set",
+            inclusive: true,
+            exact: false,
+            message: def.minSize.message
+          });
+          status.dirty();
+        }
+      }
+      if (def.maxSize !== null) {
+        if (ctx.data.size > def.maxSize.value) {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, {
+            code: ZodError_js_1.ZodIssueCode.too_big,
+            maximum: def.maxSize.value,
+            type: "set",
+            inclusive: true,
+            exact: false,
+            message: def.maxSize.message
+          });
+          status.dirty();
+        }
+      }
+      const valueType = this._def.valueType;
+      function finalizeSet(elements2) {
+        const parsedSet = new Set;
+        for (const element of elements2) {
+          if (element.status === "aborted")
+            return parseUtil_js_1.INVALID;
+          if (element.status === "dirty")
+            status.dirty();
+          parsedSet.add(element.value);
+        }
+        return { status: status.value, value: parsedSet };
+      }
+      const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+      if (ctx.common.async) {
+        return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+      } else {
+        return finalizeSet(elements);
+      }
+    }
+    min(minSize, message) {
+      return new ZodSet({
+        ...this._def,
+        minSize: { value: minSize, message: errorUtil_js_1.errorUtil.toString(message) }
+      });
+    }
+    max(maxSize, message) {
+      return new ZodSet({
+        ...this._def,
+        maxSize: { value: maxSize, message: errorUtil_js_1.errorUtil.toString(message) }
+      });
+    }
+    size(size, message) {
+      return this.min(size, message).max(size, message);
+    }
+    nonempty(message) {
+      return this.min(1, message);
+    }
+  }
+  exports.ZodSet = ZodSet;
+  ZodSet.create = (valueType, params) => {
+    return new ZodSet({
+      valueType,
+      minSize: null,
+      maxSize: null,
+      typeName: ZodFirstPartyTypeKind.ZodSet,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodFunction extends ZodType {
+    constructor() {
+      super(...arguments);
+      this.validate = this.implement;
+    }
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.function) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.function,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      function makeArgsIssue(args, error) {
+        return (0, parseUtil_js_1.makeIssue)({
+          data: args,
+          path: ctx.path,
+          errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, (0, errors_js_1.getErrorMap)(), errors_js_1.defaultErrorMap].filter((x) => !!x),
+          issueData: {
+            code: ZodError_js_1.ZodIssueCode.invalid_arguments,
+            argumentsError: error
+          }
+        });
+      }
+      function makeReturnsIssue(returns, error) {
+        return (0, parseUtil_js_1.makeIssue)({
+          data: returns,
+          path: ctx.path,
+          errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, (0, errors_js_1.getErrorMap)(), errors_js_1.defaultErrorMap].filter((x) => !!x),
+          issueData: {
+            code: ZodError_js_1.ZodIssueCode.invalid_return_type,
+            returnTypeError: error
+          }
+        });
+      }
+      const params = { errorMap: ctx.common.contextualErrorMap };
+      const fn = ctx.data;
+      if (this._def.returns instanceof ZodPromise) {
+        const me = this;
+        return (0, parseUtil_js_1.OK)(async function(...args) {
+          const error = new ZodError_js_1.ZodError([]);
+          const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+            error.addIssue(makeArgsIssue(args, e));
+            throw error;
+          });
+          const result = await Reflect.apply(fn, this, parsedArgs);
+          const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+            error.addIssue(makeReturnsIssue(result, e));
+            throw error;
+          });
+          return parsedReturns;
+        });
+      } else {
+        const me = this;
+        return (0, parseUtil_js_1.OK)(function(...args) {
+          const parsedArgs = me._def.args.safeParse(args, params);
+          if (!parsedArgs.success) {
+            throw new ZodError_js_1.ZodError([makeArgsIssue(args, parsedArgs.error)]);
+          }
+          const result = Reflect.apply(fn, this, parsedArgs.data);
+          const parsedReturns = me._def.returns.safeParse(result, params);
+          if (!parsedReturns.success) {
+            throw new ZodError_js_1.ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+          }
+          return parsedReturns.data;
+        });
+      }
+    }
+    parameters() {
+      return this._def.args;
+    }
+    returnType() {
+      return this._def.returns;
+    }
+    args(...items) {
+      return new ZodFunction({
+        ...this._def,
+        args: ZodTuple.create(items).rest(ZodUnknown.create())
+      });
+    }
+    returns(returnType) {
+      return new ZodFunction({
+        ...this._def,
+        returns: returnType
+      });
+    }
+    implement(func) {
+      const validatedFunc = this.parse(func);
+      return validatedFunc;
+    }
+    strictImplement(func) {
+      const validatedFunc = this.parse(func);
+      return validatedFunc;
+    }
+    static create(args, returns, params) {
+      return new ZodFunction({
+        args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
+        returns: returns || ZodUnknown.create(),
+        typeName: ZodFirstPartyTypeKind.ZodFunction,
+        ...processCreateParams(params)
+      });
+    }
+  }
+  exports.ZodFunction = ZodFunction;
+
+  class ZodLazy extends ZodType {
+    get schema() {
+      return this._def.getter();
+    }
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      const lazySchema = this._def.getter();
+      return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+    }
+  }
+  exports.ZodLazy = ZodLazy;
+  ZodLazy.create = (getter, params) => {
+    return new ZodLazy({
+      getter,
+      typeName: ZodFirstPartyTypeKind.ZodLazy,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodLiteral extends ZodType {
+    _parse(input) {
+      if (input.data !== this._def.value) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          received: ctx.data,
+          code: ZodError_js_1.ZodIssueCode.invalid_literal,
+          expected: this._def.value
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return { status: "valid", value: input.data };
+    }
+    get value() {
+      return this._def.value;
+    }
+  }
+  exports.ZodLiteral = ZodLiteral;
+  ZodLiteral.create = (value, params) => {
+    return new ZodLiteral({
+      value,
+      typeName: ZodFirstPartyTypeKind.ZodLiteral,
+      ...processCreateParams(params)
+    });
+  };
+  function createZodEnum(values, params) {
+    return new ZodEnum({
+      values,
+      typeName: ZodFirstPartyTypeKind.ZodEnum,
+      ...processCreateParams(params)
+    });
+  }
+
+  class ZodEnum extends ZodType {
+    _parse(input) {
+      if (typeof input.data !== "string") {
+        const ctx = this._getOrReturnCtx(input);
+        const expectedValues = this._def.values;
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          expected: util_js_1.util.joinValues(expectedValues),
+          received: ctx.parsedType,
+          code: ZodError_js_1.ZodIssueCode.invalid_type
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (!this._cache) {
+        this._cache = new Set(this._def.values);
+      }
+      if (!this._cache.has(input.data)) {
+        const ctx = this._getOrReturnCtx(input);
+        const expectedValues = this._def.values;
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          received: ctx.data,
+          code: ZodError_js_1.ZodIssueCode.invalid_enum_value,
+          options: expectedValues
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+    get options() {
+      return this._def.values;
+    }
+    get enum() {
+      const enumValues = {};
+      for (const val of this._def.values) {
+        enumValues[val] = val;
+      }
+      return enumValues;
+    }
+    get Values() {
+      const enumValues = {};
+      for (const val of this._def.values) {
+        enumValues[val] = val;
+      }
+      return enumValues;
+    }
+    get Enum() {
+      const enumValues = {};
+      for (const val of this._def.values) {
+        enumValues[val] = val;
+      }
+      return enumValues;
+    }
+    extract(values, newDef = this._def) {
+      return ZodEnum.create(values, {
+        ...this._def,
+        ...newDef
+      });
+    }
+    exclude(values, newDef = this._def) {
+      return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
+        ...this._def,
+        ...newDef
+      });
+    }
+  }
+  exports.ZodEnum = ZodEnum;
+  ZodEnum.create = createZodEnum;
+
+  class ZodNativeEnum extends ZodType {
+    _parse(input) {
+      const nativeEnumValues = util_js_1.util.getValidEnumValues(this._def.values);
+      const ctx = this._getOrReturnCtx(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.string && ctx.parsedType !== util_js_1.ZodParsedType.number) {
+        const expectedValues = util_js_1.util.objectValues(nativeEnumValues);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          expected: util_js_1.util.joinValues(expectedValues),
+          received: ctx.parsedType,
+          code: ZodError_js_1.ZodIssueCode.invalid_type
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      if (!this._cache) {
+        this._cache = new Set(util_js_1.util.getValidEnumValues(this._def.values));
+      }
+      if (!this._cache.has(input.data)) {
+        const expectedValues = util_js_1.util.objectValues(nativeEnumValues);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          received: ctx.data,
+          code: ZodError_js_1.ZodIssueCode.invalid_enum_value,
+          options: expectedValues
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return (0, parseUtil_js_1.OK)(input.data);
+    }
+    get enum() {
+      return this._def.values;
+    }
+  }
+  exports.ZodNativeEnum = ZodNativeEnum;
+  ZodNativeEnum.create = (values, params) => {
+    return new ZodNativeEnum({
+      values,
+      typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodPromise extends ZodType {
+    unwrap() {
+      return this._def.type;
+    }
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      if (ctx.parsedType !== util_js_1.ZodParsedType.promise && ctx.common.async === false) {
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.promise,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      const promisified = ctx.parsedType === util_js_1.ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+      return (0, parseUtil_js_1.OK)(promisified.then((data) => {
+        return this._def.type.parseAsync(data, {
+          path: ctx.path,
+          errorMap: ctx.common.contextualErrorMap
+        });
+      }));
+    }
+  }
+  exports.ZodPromise = ZodPromise;
+  ZodPromise.create = (schema, params) => {
+    return new ZodPromise({
+      type: schema,
+      typeName: ZodFirstPartyTypeKind.ZodPromise,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodEffects extends ZodType {
+    innerType() {
+      return this._def.schema;
+    }
+    sourceType() {
+      return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+    }
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      const effect = this._def.effect || null;
+      const checkCtx = {
+        addIssue: (arg) => {
+          (0, parseUtil_js_1.addIssueToContext)(ctx, arg);
+          if (arg.fatal) {
+            status.abort();
+          } else {
+            status.dirty();
+          }
+        },
+        get path() {
+          return ctx.path;
+        }
+      };
+      checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+      if (effect.type === "preprocess") {
+        const processed = effect.transform(ctx.data, checkCtx);
+        if (ctx.common.async) {
+          return Promise.resolve(processed).then(async (processed2) => {
+            if (status.value === "aborted")
+              return parseUtil_js_1.INVALID;
+            const result = await this._def.schema._parseAsync({
+              data: processed2,
+              path: ctx.path,
+              parent: ctx
+            });
+            if (result.status === "aborted")
+              return parseUtil_js_1.INVALID;
+            if (result.status === "dirty")
+              return (0, parseUtil_js_1.DIRTY)(result.value);
+            if (status.value === "dirty")
+              return (0, parseUtil_js_1.DIRTY)(result.value);
+            return result;
+          });
+        } else {
+          if (status.value === "aborted")
+            return parseUtil_js_1.INVALID;
+          const result = this._def.schema._parseSync({
+            data: processed,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (result.status === "aborted")
+            return parseUtil_js_1.INVALID;
+          if (result.status === "dirty")
+            return (0, parseUtil_js_1.DIRTY)(result.value);
+          if (status.value === "dirty")
+            return (0, parseUtil_js_1.DIRTY)(result.value);
+          return result;
+        }
+      }
+      if (effect.type === "refinement") {
+        const executeRefinement = (acc) => {
+          const result = effect.refinement(acc, checkCtx);
+          if (ctx.common.async) {
+            return Promise.resolve(result);
+          }
+          if (result instanceof Promise) {
+            throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+          }
+          return acc;
+        };
+        if (ctx.common.async === false) {
+          const inner = this._def.schema._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (inner.status === "aborted")
+            return parseUtil_js_1.INVALID;
+          if (inner.status === "dirty")
+            status.dirty();
+          executeRefinement(inner.value);
+          return { status: status.value, value: inner.value };
+        } else {
+          return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+            if (inner.status === "aborted")
+              return parseUtil_js_1.INVALID;
+            if (inner.status === "dirty")
+              status.dirty();
+            return executeRefinement(inner.value).then(() => {
+              return { status: status.value, value: inner.value };
+            });
+          });
+        }
+      }
+      if (effect.type === "transform") {
+        if (ctx.common.async === false) {
+          const base = this._def.schema._parseSync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (!(0, parseUtil_js_1.isValid)(base))
+            return parseUtil_js_1.INVALID;
+          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 (!(0, parseUtil_js_1.isValid)(base))
+              return parseUtil_js_1.INVALID;
+            return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+              status: status.value,
+              value: result
+            }));
+          });
+        }
+      }
+      util_js_1.util.assertNever(effect);
+    }
+  }
+  exports.ZodEffects = ZodEffects;
+  exports.ZodTransformer = ZodEffects;
+  ZodEffects.create = (schema, effect, params) => {
+    return new ZodEffects({
+      schema,
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      effect,
+      ...processCreateParams(params)
+    });
+  };
+  ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+    return new ZodEffects({
+      schema,
+      effect: { type: "preprocess", transform: preprocess },
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodOptional extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType === util_js_1.ZodParsedType.undefined) {
+        return (0, parseUtil_js_1.OK)(undefined);
+      }
+      return this._def.innerType._parse(input);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  exports.ZodOptional = ZodOptional;
+  ZodOptional.create = (type, params) => {
+    return new ZodOptional({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodOptional,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodNullable extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType === util_js_1.ZodParsedType.null) {
+        return (0, parseUtil_js_1.OK)(null);
+      }
+      return this._def.innerType._parse(input);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  exports.ZodNullable = ZodNullable;
+  ZodNullable.create = (type, params) => {
+    return new ZodNullable({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodNullable,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodDefault extends ZodType {
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      let data = ctx.data;
+      if (ctx.parsedType === util_js_1.ZodParsedType.undefined) {
+        data = this._def.defaultValue();
+      }
+      return this._def.innerType._parse({
+        data,
+        path: ctx.path,
+        parent: ctx
+      });
+    }
+    removeDefault() {
+      return this._def.innerType;
+    }
+  }
+  exports.ZodDefault = ZodDefault;
+  ZodDefault.create = (type, params) => {
+    return new ZodDefault({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodDefault,
+      defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodCatch extends ZodType {
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      const newCtx = {
+        ...ctx,
+        common: {
+          ...ctx.common,
+          issues: []
+        }
+      };
+      const result = this._def.innerType._parse({
+        data: newCtx.data,
+        path: newCtx.path,
+        parent: {
+          ...newCtx
+        }
+      });
+      if ((0, parseUtil_js_1.isAsync)(result)) {
+        return result.then((result2) => {
+          return {
+            status: "valid",
+            value: result2.status === "valid" ? result2.value : this._def.catchValue({
+              get error() {
+                return new ZodError_js_1.ZodError(newCtx.common.issues);
+              },
+              input: newCtx.data
+            })
+          };
+        });
+      } else {
+        return {
+          status: "valid",
+          value: result.status === "valid" ? result.value : this._def.catchValue({
+            get error() {
+              return new ZodError_js_1.ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
+      }
+    }
+    removeCatch() {
+      return this._def.innerType;
+    }
+  }
+  exports.ZodCatch = ZodCatch;
+  ZodCatch.create = (type, params) => {
+    return new ZodCatch({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodCatch,
+      catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
+      ...processCreateParams(params)
+    });
+  };
+
+  class ZodNaN extends ZodType {
+    _parse(input) {
+      const parsedType = this._getType(input);
+      if (parsedType !== util_js_1.ZodParsedType.nan) {
+        const ctx = this._getOrReturnCtx(input);
+        (0, parseUtil_js_1.addIssueToContext)(ctx, {
+          code: ZodError_js_1.ZodIssueCode.invalid_type,
+          expected: util_js_1.ZodParsedType.nan,
+          received: ctx.parsedType
+        });
+        return parseUtil_js_1.INVALID;
+      }
+      return { status: "valid", value: input.data };
+    }
+  }
+  exports.ZodNaN = ZodNaN;
+  ZodNaN.create = (params) => {
+    return new ZodNaN({
+      typeName: ZodFirstPartyTypeKind.ZodNaN,
+      ...processCreateParams(params)
+    });
+  };
+  exports.BRAND = Symbol("zod_brand");
+
+  class ZodBranded extends ZodType {
+    _parse(input) {
+      const { ctx } = this._processInputParams(input);
+      const data = ctx.data;
+      return this._def.type._parse({
+        data,
+        path: ctx.path,
+        parent: ctx
+      });
+    }
+    unwrap() {
+      return this._def.type;
+    }
+  }
+  exports.ZodBranded = ZodBranded;
+
+  class ZodPipeline extends ZodType {
+    _parse(input) {
+      const { status, ctx } = this._processInputParams(input);
+      if (ctx.common.async) {
+        const handleAsync = async () => {
+          const inResult = await this._def.in._parseAsync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (inResult.status === "aborted")
+            return parseUtil_js_1.INVALID;
+          if (inResult.status === "dirty") {
+            status.dirty();
+            return (0, parseUtil_js_1.DIRTY)(inResult.value);
+          } else {
+            return this._def.out._parseAsync({
+              data: inResult.value,
+              path: ctx.path,
+              parent: ctx
+            });
+          }
+        };
+        return handleAsync();
+      } else {
+        const inResult = this._def.in._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return parseUtil_js_1.INVALID;
+        if (inResult.status === "dirty") {
+          status.dirty();
+          return {
+            status: "dirty",
+            value: inResult.value
+          };
+        } else {
+          return this._def.out._parseSync({
+            data: inResult.value,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      }
+    }
+    static create(a, b) {
+      return new ZodPipeline({
+        in: a,
+        out: b,
+        typeName: ZodFirstPartyTypeKind.ZodPipeline
+      });
+    }
+  }
+  exports.ZodPipeline = ZodPipeline;
+
+  class ZodReadonly extends ZodType {
+    _parse(input) {
+      const result = this._def.innerType._parse(input);
+      const freeze = (data) => {
+        if ((0, parseUtil_js_1.isValid)(data)) {
+          data.value = Object.freeze(data.value);
+        }
+        return data;
+      };
+      return (0, parseUtil_js_1.isAsync)(result) ? result.then((data) => freeze(data)) : freeze(result);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  exports.ZodReadonly = ZodReadonly;
+  ZodReadonly.create = (type, params) => {
+    return new ZodReadonly({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodReadonly,
+      ...processCreateParams(params)
+    });
+  };
+  function cleanParams(params, data) {
+    const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+    const p2 = typeof p === "string" ? { message: p } : p;
+    return p2;
+  }
+  function custom(check, _params = {}, fatal) {
+    if (check)
+      return ZodAny.create().superRefine((data, ctx) => {
+        const r = check(data);
+        if (r instanceof Promise) {
+          return r.then((r2) => {
+            if (!r2) {
+              const params = cleanParams(_params, data);
+              const _fatal = params.fatal ?? fatal ?? true;
+              ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+            }
+          });
+        }
+        if (!r) {
+          const params = cleanParams(_params, data);
+          const _fatal = params.fatal ?? fatal ?? true;
+          ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+        }
+        return;
+      });
+    return ZodAny.create();
+  }
+  exports.late = {
+    object: ZodObject.lazycreate
+  };
+  var ZodFirstPartyTypeKind;
+  (function(ZodFirstPartyTypeKind2) {
+    ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+    ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+    ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+    ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+    ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+    ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+    ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+    ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+    ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+    ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+    ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+    ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+    ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+    ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+    ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+    ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+    ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+    ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+    ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+    ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+    ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+    ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+    ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+    ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+    ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+    ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+    ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+    ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+    ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+    ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+    ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+    ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+    ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+    ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+    ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+    ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+  })(ZodFirstPartyTypeKind || (exports.ZodFirstPartyTypeKind = ZodFirstPartyTypeKind = {}));
+  var instanceOfType = (cls, params = {
+    message: `Input not instance of ${cls.name}`
+  }) => custom((data) => data instanceof cls, params);
+  exports.instanceof = instanceOfType;
+  var stringType = ZodString.create;
+  exports.string = stringType;
+  var numberType = ZodNumber.create;
+  exports.number = numberType;
+  var nanType = ZodNaN.create;
+  exports.nan = nanType;
+  var bigIntType = ZodBigInt.create;
+  exports.bigint = bigIntType;
+  var booleanType = ZodBoolean.create;
+  exports.boolean = booleanType;
+  var dateType = ZodDate.create;
+  exports.date = dateType;
+  var symbolType = ZodSymbol.create;
+  exports.symbol = symbolType;
+  var undefinedType = ZodUndefined.create;
+  exports.undefined = undefinedType;
+  var nullType = ZodNull.create;
+  exports.null = nullType;
+  var anyType = ZodAny.create;
+  exports.any = anyType;
+  var unknownType = ZodUnknown.create;
+  exports.unknown = unknownType;
+  var neverType = ZodNever.create;
+  exports.never = neverType;
+  var voidType = ZodVoid.create;
+  exports.void = voidType;
+  var arrayType = ZodArray.create;
+  exports.array = arrayType;
+  var objectType = ZodObject.create;
+  exports.object = objectType;
+  var strictObjectType = ZodObject.strictCreate;
+  exports.strictObject = strictObjectType;
+  var unionType = ZodUnion.create;
+  exports.union = unionType;
+  var discriminatedUnionType = ZodDiscriminatedUnion.create;
+  exports.discriminatedUnion = discriminatedUnionType;
+  var intersectionType = ZodIntersection.create;
+  exports.intersection = intersectionType;
+  var tupleType = ZodTuple.create;
+  exports.tuple = tupleType;
+  var recordType = ZodRecord.create;
+  exports.record = recordType;
+  var mapType = ZodMap.create;
+  exports.map = mapType;
+  var setType = ZodSet.create;
+  exports.set = setType;
+  var functionType = ZodFunction.create;
+  exports.function = functionType;
+  var lazyType = ZodLazy.create;
+  exports.lazy = lazyType;
+  var literalType = ZodLiteral.create;
+  exports.literal = literalType;
+  var enumType = ZodEnum.create;
+  exports.enum = enumType;
+  var nativeEnumType = ZodNativeEnum.create;
+  exports.nativeEnum = nativeEnumType;
+  var promiseType = ZodPromise.create;
+  exports.promise = promiseType;
+  var effectsType = ZodEffects.create;
+  exports.effect = effectsType;
+  exports.transformer = effectsType;
+  var optionalType = ZodOptional.create;
+  exports.optional = optionalType;
+  var nullableType = ZodNullable.create;
+  exports.nullable = nullableType;
+  var preprocessType = ZodEffects.createWithPreprocess;
+  exports.preprocess = preprocessType;
+  var pipelineType = ZodPipeline.create;
+  exports.pipeline = pipelineType;
+  var ostring = () => stringType().optional();
+  exports.ostring = ostring;
+  var onumber = () => numberType().optional();
+  exports.onumber = onumber;
+  var oboolean = () => booleanType().optional();
+  exports.oboolean = oboolean;
+  exports.coerce = {
+    string: (arg) => ZodString.create({ ...arg, coerce: true }),
+    number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+    boolean: (arg) => ZodBoolean.create({
+      ...arg,
+      coerce: true
+    }),
+    bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+    date: (arg) => ZodDate.create({ ...arg, coerce: true })
+  };
+  exports.NEVER = parseUtil_js_1.INVALID;
+});
+var require_external = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_errors(), exports);
+  __exportStar(require_parseUtil(), exports);
+  __exportStar(require_typeAliases(), exports);
+  __exportStar(require_util(), exports);
+  __exportStar(require_types(), exports);
+  __exportStar(require_ZodError(), exports);
+});
+var require_zod = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.z = undefined;
+  var z = __importStar(require_external());
+  exports.z = z;
+  __exportStar(require_external(), exports);
+  exports.default = z;
+});
+var require_dist = __commonJS((exports, module) => {
+  var __defProp2 = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames2 = Object.getOwnPropertyNames;
+  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp2(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (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)
+          __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp2({}, "__esModule", { value: true }), mod);
+  var index_exports = {};
+  __export(index_exports, {
+    AGUIConnectNotImplementedError: () => AGUIConnectNotImplementedError,
+    AGUIError: () => AGUIError,
+    ActivityDeltaEventSchema: () => ActivityDeltaEventSchema,
+    ActivityMessageSchema: () => ActivityMessageSchema,
+    ActivitySnapshotEventSchema: () => ActivitySnapshotEventSchema,
+    AssistantMessageSchema: () => AssistantMessageSchema,
+    BaseEventSchema: () => BaseEventSchema,
+    BaseMessageSchema: () => BaseMessageSchema,
+    BinaryInputContentSchema: () => BinaryInputContentSchema,
+    ContextSchema: () => ContextSchema,
+    CustomEventSchema: () => CustomEventSchema,
+    DeveloperMessageSchema: () => DeveloperMessageSchema,
+    EventSchemas: () => EventSchemas,
+    EventType: () => EventType,
+    FunctionCallSchema: () => FunctionCallSchema,
+    InputContentSchema: () => InputContentSchema,
+    MessageSchema: () => MessageSchema,
+    MessagesSnapshotEventSchema: () => MessagesSnapshotEventSchema,
+    RawEventSchema: () => RawEventSchema,
+    RoleSchema: () => RoleSchema,
+    RunAgentInputSchema: () => RunAgentInputSchema,
+    RunErrorEventSchema: () => RunErrorEventSchema,
+    RunFinishedEventSchema: () => RunFinishedEventSchema,
+    RunStartedEventSchema: () => RunStartedEventSchema,
+    StateDeltaEventSchema: () => StateDeltaEventSchema,
+    StateSchema: () => StateSchema,
+    StateSnapshotEventSchema: () => StateSnapshotEventSchema,
+    StepFinishedEventSchema: () => StepFinishedEventSchema,
+    StepStartedEventSchema: () => StepStartedEventSchema,
+    SystemMessageSchema: () => SystemMessageSchema,
+    TextInputContentSchema: () => TextInputContentSchema,
+    TextMessageChunkEventSchema: () => TextMessageChunkEventSchema,
+    TextMessageContentEventSchema: () => TextMessageContentEventSchema,
+    TextMessageEndEventSchema: () => TextMessageEndEventSchema,
+    TextMessageStartEventSchema: () => TextMessageStartEventSchema,
+    ThinkingEndEventSchema: () => ThinkingEndEventSchema,
+    ThinkingStartEventSchema: () => ThinkingStartEventSchema,
+    ThinkingTextMessageContentEventSchema: () => ThinkingTextMessageContentEventSchema,
+    ThinkingTextMessageEndEventSchema: () => ThinkingTextMessageEndEventSchema,
+    ThinkingTextMessageStartEventSchema: () => ThinkingTextMessageStartEventSchema,
+    ToolCallArgsEventSchema: () => ToolCallArgsEventSchema,
+    ToolCallChunkEventSchema: () => ToolCallChunkEventSchema,
+    ToolCallEndEventSchema: () => ToolCallEndEventSchema,
+    ToolCallResultEventSchema: () => ToolCallResultEventSchema,
+    ToolCallSchema: () => ToolCallSchema,
+    ToolCallStartEventSchema: () => ToolCallStartEventSchema,
+    ToolMessageSchema: () => ToolMessageSchema,
+    ToolSchema: () => ToolSchema,
+    UserMessageSchema: () => UserMessageSchema
+  });
+  module.exports = __toCommonJS(index_exports);
+  var import_zod = require_zod();
+  var FunctionCallSchema = import_zod.z.object({
+    name: import_zod.z.string(),
+    arguments: import_zod.z.string()
+  });
+  var ToolCallSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    type: import_zod.z.literal("function"),
+    function: FunctionCallSchema
+  });
+  var BaseMessageSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    role: import_zod.z.string(),
+    content: import_zod.z.string().optional(),
+    name: import_zod.z.string().optional()
+  });
+  var TextInputContentSchema = import_zod.z.object({
+    type: import_zod.z.literal("text"),
+    text: import_zod.z.string()
+  });
+  var BinaryInputContentObjectSchema = import_zod.z.object({
+    type: import_zod.z.literal("binary"),
+    mimeType: import_zod.z.string(),
+    id: import_zod.z.string().optional(),
+    url: import_zod.z.string().optional(),
+    data: import_zod.z.string().optional(),
+    filename: import_zod.z.string().optional()
+  });
+  var ensureBinaryPayload = (value, ctx) => {
+    if (!value.id && !value.url && !value.data) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "BinaryInputContent requires at least one of id, url, or data.",
+        path: ["id"]
+      });
+    }
+  };
+  var BinaryInputContentSchema = BinaryInputContentObjectSchema.superRefine((value, ctx) => {
+    ensureBinaryPayload(value, ctx);
+  });
+  var InputContentBaseSchema = import_zod.z.discriminatedUnion("type", [
+    TextInputContentSchema,
+    BinaryInputContentObjectSchema
+  ]);
+  var InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
+    if (value.type === "binary") {
+      ensureBinaryPayload(value, ctx);
+    }
+  });
+  var DeveloperMessageSchema = BaseMessageSchema.extend({
+    role: import_zod.z.literal("developer"),
+    content: import_zod.z.string()
+  });
+  var SystemMessageSchema = BaseMessageSchema.extend({
+    role: import_zod.z.literal("system"),
+    content: import_zod.z.string()
+  });
+  var AssistantMessageSchema = BaseMessageSchema.extend({
+    role: import_zod.z.literal("assistant"),
+    content: import_zod.z.string().optional(),
+    toolCalls: import_zod.z.array(ToolCallSchema).optional()
+  });
+  var UserMessageSchema = BaseMessageSchema.extend({
+    role: import_zod.z.literal("user"),
+    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(InputContentSchema)])
+  });
+  var ToolMessageSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    content: import_zod.z.string(),
+    role: import_zod.z.literal("tool"),
+    toolCallId: import_zod.z.string(),
+    error: import_zod.z.string().optional()
+  });
+  var ActivityMessageSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    role: import_zod.z.literal("activity"),
+    activityType: import_zod.z.string(),
+    content: import_zod.z.record(import_zod.z.any())
+  });
+  var MessageSchema = import_zod.z.discriminatedUnion("role", [
+    DeveloperMessageSchema,
+    SystemMessageSchema,
+    AssistantMessageSchema,
+    UserMessageSchema,
+    ToolMessageSchema,
+    ActivityMessageSchema
+  ]);
+  var RoleSchema = import_zod.z.union([
+    import_zod.z.literal("developer"),
+    import_zod.z.literal("system"),
+    import_zod.z.literal("assistant"),
+    import_zod.z.literal("user"),
+    import_zod.z.literal("tool"),
+    import_zod.z.literal("activity")
+  ]);
+  var ContextSchema = import_zod.z.object({
+    description: import_zod.z.string(),
+    value: import_zod.z.string()
+  });
+  var ToolSchema = import_zod.z.object({
+    name: import_zod.z.string(),
+    description: import_zod.z.string(),
+    parameters: import_zod.z.any()
+  });
+  var RunAgentInputSchema = import_zod.z.object({
+    threadId: import_zod.z.string(),
+    runId: import_zod.z.string(),
+    parentRunId: import_zod.z.string().optional(),
+    state: import_zod.z.any(),
+    messages: import_zod.z.array(MessageSchema),
+    tools: import_zod.z.array(ToolSchema),
+    context: import_zod.z.array(ContextSchema),
+    forwardedProps: import_zod.z.any()
+  });
+  var StateSchema = import_zod.z.any();
+  var AGUIError = class extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  var AGUIConnectNotImplementedError = class extends AGUIError {
+    constructor() {
+      super("Connect not implemented. This method is not supported by the current agent.");
+    }
+  };
+  var import_zod2 = require_zod();
+  var TextMessageRoleSchema = import_zod2.z.union([
+    import_zod2.z.literal("developer"),
+    import_zod2.z.literal("system"),
+    import_zod2.z.literal("assistant"),
+    import_zod2.z.literal("user")
+  ]);
+  var EventType = /* @__PURE__ */ ((EventType2) => {
+    EventType2["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
+    EventType2["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
+    EventType2["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
+    EventType2["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
+    EventType2["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
+    EventType2["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
+    EventType2["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
+    EventType2["TOOL_CALL_START"] = "TOOL_CALL_START";
+    EventType2["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
+    EventType2["TOOL_CALL_END"] = "TOOL_CALL_END";
+    EventType2["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
+    EventType2["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
+    EventType2["THINKING_START"] = "THINKING_START";
+    EventType2["THINKING_END"] = "THINKING_END";
+    EventType2["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
+    EventType2["STATE_DELTA"] = "STATE_DELTA";
+    EventType2["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
+    EventType2["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
+    EventType2["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
+    EventType2["RAW"] = "RAW";
+    EventType2["CUSTOM"] = "CUSTOM";
+    EventType2["RUN_STARTED"] = "RUN_STARTED";
+    EventType2["RUN_FINISHED"] = "RUN_FINISHED";
+    EventType2["RUN_ERROR"] = "RUN_ERROR";
+    EventType2["STEP_STARTED"] = "STEP_STARTED";
+    EventType2["STEP_FINISHED"] = "STEP_FINISHED";
+    return EventType2;
+  })(EventType || {});
+  var BaseEventSchema = import_zod2.z.object({
+    type: import_zod2.z.nativeEnum(EventType),
+    timestamp: import_zod2.z.number().optional(),
+    rawEvent: import_zod2.z.any().optional()
+  });
+  var TextMessageStartEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TEXT_MESSAGE_START"),
+    messageId: import_zod2.z.string(),
+    role: TextMessageRoleSchema.default("assistant")
+  });
+  var TextMessageContentEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TEXT_MESSAGE_CONTENT"),
+    messageId: import_zod2.z.string(),
+    delta: import_zod2.z.string().refine((s) => s.length > 0, "Delta must not be an empty string")
+  });
+  var TextMessageEndEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TEXT_MESSAGE_END"),
+    messageId: import_zod2.z.string()
+  });
+  var TextMessageChunkEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TEXT_MESSAGE_CHUNK"),
+    messageId: import_zod2.z.string().optional(),
+    role: TextMessageRoleSchema.optional(),
+    delta: import_zod2.z.string().optional()
+  });
+  var ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_START")
+  });
+  var ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
+    messageId: true,
+    type: true
+  }).extend({
+    type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_CONTENT")
+  });
+  var ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_END")
+  });
+  var ToolCallStartEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TOOL_CALL_START"),
+    toolCallId: import_zod2.z.string(),
+    toolCallName: import_zod2.z.string(),
+    parentMessageId: import_zod2.z.string().optional()
+  });
+  var ToolCallArgsEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TOOL_CALL_ARGS"),
+    toolCallId: import_zod2.z.string(),
+    delta: import_zod2.z.string()
+  });
+  var ToolCallEndEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TOOL_CALL_END"),
+    toolCallId: import_zod2.z.string()
+  });
+  var ToolCallResultEventSchema = BaseEventSchema.extend({
+    messageId: import_zod2.z.string(),
+    type: import_zod2.z.literal("TOOL_CALL_RESULT"),
+    toolCallId: import_zod2.z.string(),
+    content: import_zod2.z.string(),
+    role: import_zod2.z.literal("tool").optional()
+  });
+  var ToolCallChunkEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("TOOL_CALL_CHUNK"),
+    toolCallId: import_zod2.z.string().optional(),
+    toolCallName: import_zod2.z.string().optional(),
+    parentMessageId: import_zod2.z.string().optional(),
+    delta: import_zod2.z.string().optional()
+  });
+  var ThinkingStartEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("THINKING_START"),
+    title: import_zod2.z.string().optional()
+  });
+  var ThinkingEndEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("THINKING_END")
+  });
+  var StateSnapshotEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("STATE_SNAPSHOT"),
+    snapshot: StateSchema
+  });
+  var StateDeltaEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("STATE_DELTA"),
+    delta: import_zod2.z.array(import_zod2.z.any())
+  });
+  var MessagesSnapshotEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("MESSAGES_SNAPSHOT"),
+    messages: import_zod2.z.array(MessageSchema)
+  });
+  var ActivitySnapshotEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("ACTIVITY_SNAPSHOT"),
+    messageId: import_zod2.z.string(),
+    activityType: import_zod2.z.string(),
+    content: import_zod2.z.record(import_zod2.z.any()),
+    replace: import_zod2.z.boolean().optional().default(true)
+  });
+  var ActivityDeltaEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("ACTIVITY_DELTA"),
+    messageId: import_zod2.z.string(),
+    activityType: import_zod2.z.string(),
+    patch: import_zod2.z.array(import_zod2.z.any())
+  });
+  var RawEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("RAW"),
+    event: import_zod2.z.any(),
+    source: import_zod2.z.string().optional()
+  });
+  var CustomEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("CUSTOM"),
+    name: import_zod2.z.string(),
+    value: import_zod2.z.any()
+  });
+  var RunStartedEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("RUN_STARTED"),
+    threadId: import_zod2.z.string(),
+    runId: import_zod2.z.string(),
+    parentRunId: import_zod2.z.string().optional(),
+    input: RunAgentInputSchema.optional()
+  });
+  var RunFinishedEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("RUN_FINISHED"),
+    threadId: import_zod2.z.string(),
+    runId: import_zod2.z.string(),
+    result: import_zod2.z.any().optional()
+  });
+  var RunErrorEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("RUN_ERROR"),
+    message: import_zod2.z.string(),
+    code: import_zod2.z.string().optional()
+  });
+  var StepStartedEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("STEP_STARTED"),
+    stepName: import_zod2.z.string()
+  });
+  var StepFinishedEventSchema = BaseEventSchema.extend({
+    type: import_zod2.z.literal("STEP_FINISHED"),
+    stepName: import_zod2.z.string()
+  });
+  var EventSchemas = import_zod2.z.discriminatedUnion("type", [
+    TextMessageStartEventSchema,
+    TextMessageContentEventSchema,
+    TextMessageEndEventSchema,
+    TextMessageChunkEventSchema,
+    ThinkingStartEventSchema,
+    ThinkingEndEventSchema,
+    ThinkingTextMessageStartEventSchema,
+    ThinkingTextMessageContentEventSchema,
+    ThinkingTextMessageEndEventSchema,
+    ToolCallStartEventSchema,
+    ToolCallArgsEventSchema,
+    ToolCallEndEventSchema,
+    ToolCallChunkEventSchema,
+    ToolCallResultEventSchema,
+    StateSnapshotEventSchema,
+    StateDeltaEventSchema,
+    MessagesSnapshotEventSchema,
+    ActivitySnapshotEventSchema,
+    ActivityDeltaEventSchema,
+    RawEventSchema,
+    CustomEventSchema,
+    RunStartedEventSchema,
+    RunFinishedEventSchema,
+    RunErrorEventSchema,
+    StepStartedEventSchema,
+    StepFinishedEventSchema
+  ]);
+});
+var import_core = __toESM(require_dist(), 1);
+var ErrorCode;
+((ErrorCode2) => {
+  ErrorCode2["API_OVERLOADED"] = "API_OVERLOADED";
+  ErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(ErrorCode ||= {});
+var export_EventType = import_core.EventType;
+
+// src/WorkflowsPlugin.ts
+class WorkflowsPlugin {
+  runners;
+  constructor(config) {
+    this.runners = config.runners;
+  }
+  getName() {
+    return "workflows";
+  }
+  registerHandlers(server) {
+    server.registerMessageHandler("run_workflow", this.handleRunWorkflow.bind(this));
+  }
+  async handleRunWorkflow(session, message) {
+    const workflowMessage = message;
+    const { runner: runnerName, workflowId, inputs, tools, runId, threadId, forwardedProps } = workflowMessage.data;
+    const mcpHeaders = forwardedProps?.mcpHeaders;
+    logger.info("Running workflow", {
+      runner: runnerName,
+      workflowId,
+      toolCount: tools?.length || 0
+    });
+    const runner = this.runners.get(runnerName);
+    if (!runner) {
+      const availableRunners = Array.from(this.runners.keys()).join(", ");
+      logger.error("Workflow runner not found", {
+        requestedRunner: runnerName,
+        availableRunners: Array.from(this.runners.keys())
+      });
+      session.socket.emit("event", {
+        type: export_EventType.RUN_ERROR,
+        message: `Workflow runner "${runnerName}" not found. Available runners: ${availableRunners}`,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    session.threadId = threadId;
+    session.currentRunId = runId;
+    session.tools = (tools || []).map((t) => ({
+      ...t,
+      parameters: t.parameters || { type: "object", properties: {}, required: [] }
+    }));
+    session.state = inputs;
+    session.currentMcpHeaders = mcpHeaders;
+    const eventEmitter = {
+      emit: (event) => {
+        session.socket.emit("event", event);
+      }
+    };
+    try {
+      const result = await runner.execute({
+        session,
+        runId,
+        threadId,
+        workflowId,
+        inputs,
+        tools: session.tools
+      }, eventEmitter);
+      if (result.success) {
+        logger.info("Workflow completed successfully", {
+          runner: runnerName,
+          workflowId
+        });
+      } else {
+        logger.error("Workflow failed", {
+          runner: runnerName,
+          workflowId,
+          error: result.error
+        });
+      }
+    } finally {
+      delete session.currentMcpHeaders;
+    }
+  }
+}
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0;i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0;i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+// src/runners/DifyWorkflowRunner.ts
+class DifyWorkflowRunner {
+  apiBaseUrl;
+  workflows;
+  constructor(config) {
+    this.apiBaseUrl = config.apiBaseUrl.replace(/\/$/, "");
+    this.workflows = config.workflows;
+  }
+  getName() {
+    return "dify";
+  }
+  async execute(input, events) {
+    const { session, runId, threadId, workflowId, inputs } = input;
+    const apiKey = this.workflows[workflowId] || workflowId;
+    try {
+      const runAgentInput = {
+        threadId,
+        runId,
+        messages: [],
+        tools: input.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        })),
+        state: inputs,
+        context: []
+      };
+      events.emit({
+        type: export_EventType.RUN_STARTED,
+        threadId,
+        runId,
+        input: runAgentInput,
+        timestamp: Date.now()
+      });
+      const url = `${this.apiBaseUrl}/workflows/run`;
+      const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      };
+      const requestBody = {
+        inputs,
+        response_mode: "streaming",
+        user: session.clientId
+      };
+      console.log("[DifyWorkflowRunner] Sending request to Dify:");
+      console.log("  URL:", url);
+      console.log("  Request body:", JSON.stringify(requestBody, null, 2));
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), 1e5);
+      let response;
+      try {
+        response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(requestBody),
+          signal: controller.signal
+        });
+      } catch (fetchError) {
+        if (fetchError instanceof Error && fetchError.name === "AbortError") {
+          throw new Error(`Request to Dify timed out after 100 seconds. Check that Dify is running at ${this.apiBaseUrl}`);
+        }
+        throw new Error(`Failed to connect to Dify at ${this.apiBaseUrl}: ${fetchError instanceof Error ? fetchError.message : "Unknown error"}`);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `Dify API error: ${response.status}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.message || errorJson.error || errorText;
+        } catch {
+          errorMessage = errorText || errorMessage;
+        }
+        if (response.status === 404) {
+          errorMessage = `Workflow '${workflowId}' not found. Please create it in Dify first.`;
+        } else if (response.status === 401) {
+          errorMessage = `Dify API authentication failed. Check your API key.`;
+        } else if (response.status === 500) {
+          errorMessage = `Dify internal error: ${errorMessage}. Check workflow configuration and Dify logs.`;
+        }
+        throw new Error(errorMessage);
+      }
+      console.log(`Dify response status: ${response.status}, streaming: ${!!response.body}`);
+      if (response.body) {
+        await this.handleStreamingResponse(response.body, events, threadId, runId);
+      } else {
+        throw new Error("No response body received from Dify");
+      }
+      return {
+        success: true,
+        output: {}
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      events.emit({
+        type: export_EventType.RUN_ERROR,
+        message: errorMessage,
+        timestamp: Date.now()
+      });
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  async handleStreamingResponse(body, events, threadId, runId) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder;
+    const messageId = v4_default();
+    let fullText = "";
+    let hasReceivedData = false;
+    let hasStartedMessage = false;
+    try {
+      const timeout = 1e5;
+      let timeoutId = null;
+      const readWithTimeout = async () => {
+        return new Promise((resolve, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(new Error("Streaming timeout: No data received from Dify in 100 seconds"));
+          }, timeout);
+          reader.read().then((result) => {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            resolve(result);
+          }).catch((error) => {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            reject(error);
+          });
+        });
+      };
+      while (true) {
+        const { done, value } = await readWithTimeout();
+        if (done)
+          break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split(`
+`);
+        for (const line of lines) {
+          if (line.startsWith("data:")) {
+            const data = line.slice(5).trim();
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.event === "text_chunk" || parsed.event === "agent_message") {
+                const text = parsed.data?.text || parsed.data?.chunk || "";
+                if (text) {
+                  if (!hasStartedMessage) {
+                    events.emit({
+                      type: export_EventType.TEXT_MESSAGE_START,
+                      messageId,
+                      role: "assistant",
+                      timestamp: Date.now()
+                    });
+                    hasStartedMessage = true;
+                  }
+                  hasReceivedData = true;
+                  fullText += text;
+                  events.emit({
+                    type: export_EventType.TEXT_MESSAGE_CONTENT,
+                    messageId,
+                    delta: text,
+                    timestamp: Date.now()
+                  });
+                }
+              } else if (parsed.event === "workflow_finished") {
+                console.log("[DifyWorkflowRunner] Workflow finished:", parsed.data);
+              }
+            } catch (e) {
+              continue;
+            }
+          }
+        }
+      }
+      if (!hasReceivedData) {
+        throw new Error("No response received from Dify workflow. Check that the workflow is properly configured with output nodes.");
+      }
+      if (hasStartedMessage) {
+        events.emit({
+          type: export_EventType.TEXT_MESSAGE_END,
+          messageId,
+          timestamp: Date.now()
+        });
+      }
+      events.emit({
+        type: export_EventType.RUN_FINISHED,
+        threadId,
+        runId,
+        result: fullText,
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      throw new Error(`Streaming error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+export {
+  WorkflowsPlugin,
+  DifyWorkflowRunner
+};