@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.1

package/lib/myLib/zod/src/v4/core/api.js

@@ -0,0 +1,1256 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.map.js";
+import * as checks from "./checks.js";
+import * as registries from "./registries.js";
+import * as schemas from "./schemas.js";
+import * as util from "./util.js";
+
+// strips types that are not exposed in the public factory
+// incl. `error`, `check`
+
+// strips types that are not exposed in the public factory
+// incl. `type`, `checks`, `error`, `check`, `format`
+
+// String
+
+// @__NO_SIDE_EFFECTS__
+export function _string(Class, params) {
+  return new Class(_objectSpread({
+    type: "string"
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _coercedString(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    coerce: true
+  }, util.normalizeParams(params)));
+}
+
+// custom format
+
+// Email
+
+// @__NO_SIDE_EFFECTS__
+export function _email(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// GUID
+
+// @__NO_SIDE_EFFECTS__
+export function _guid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// UUID
+
+// @__NO_SIDE_EFFECTS__
+export function _uuid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// UUIDv4
+
+// @__NO_SIDE_EFFECTS__
+export function _uuidv4(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v4"
+  }, util.normalizeParams(params)));
+}
+
+// UUIDv6
+
+// @__NO_SIDE_EFFECTS__
+export function _uuidv6(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v6"
+  }, util.normalizeParams(params)));
+}
+
+// UUIDv7
+
+// @__NO_SIDE_EFFECTS__
+export function _uuidv7(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v7"
+  }, util.normalizeParams(params)));
+}
+
+// URL
+
+// @__NO_SIDE_EFFECTS__
+export function _url(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// Emoji
+
+// @__NO_SIDE_EFFECTS__
+export function _emoji(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// NanoID
+
+// @__NO_SIDE_EFFECTS__
+export function _nanoid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// CUID
+
+// @__NO_SIDE_EFFECTS__
+export function _cuid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// CUID2
+
+// @__NO_SIDE_EFFECTS__
+export function _cuid2(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// ULID
+
+// @__NO_SIDE_EFFECTS__
+export function _ulid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// XID
+
+// @__NO_SIDE_EFFECTS__
+export function _xid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// KSUID
+
+// @__NO_SIDE_EFFECTS__
+export function _ksuid(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// IPv4
+
+// @__NO_SIDE_EFFECTS__
+export function _ipv4(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// IPv6
+
+// @__NO_SIDE_EFFECTS__
+export function _ipv6(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// MAC
+
+// @__NO_SIDE_EFFECTS__
+export function _mac(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "mac",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// CIDRv4
+
+// @__NO_SIDE_EFFECTS__
+export function _cidrv4(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// CIDRv6
+
+// @__NO_SIDE_EFFECTS__
+export function _cidrv6(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// Base64
+
+// @__NO_SIDE_EFFECTS__
+export function _base64(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// base64url
+
+// @__NO_SIDE_EFFECTS__
+export function _base64url(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// E164
+
+// @__NO_SIDE_EFFECTS__
+export function _e164(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+
+// JWT
+
+// @__NO_SIDE_EFFECTS__
+export function _jwt(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "jwt",
+    check: "string_format",
+    abort: false
+  }, util.normalizeParams(params)));
+}
+export const TimePrecision = {
+  Any: null,
+  Minute: -1,
+  Second: 0,
+  Millisecond: 3,
+  Microsecond: 6
+};
+// ISODateTime
+
+// @__NO_SIDE_EFFECTS__
+export function _isoDateTime(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: false,
+    local: false,
+    precision: null
+  }, util.normalizeParams(params)));
+}
+
+// ISODate
+
+// @__NO_SIDE_EFFECTS__
+export function _isoDate(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "date",
+    check: "string_format"
+  }, util.normalizeParams(params)));
+}
+
+// ISOTime
+
+// @__NO_SIDE_EFFECTS__
+export function _isoTime(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null
+  }, util.normalizeParams(params)));
+}
+
+// ISODuration
+
+// @__NO_SIDE_EFFECTS__
+export function _isoDuration(Class, params) {
+  return new Class(_objectSpread({
+    type: "string",
+    format: "duration",
+    check: "string_format"
+  }, util.normalizeParams(params)));
+}
+
+// Number
+
+// @__NO_SIDE_EFFECTS__
+export function _number(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    checks: []
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _coercedNumber(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    coerce: true,
+    checks: []
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _int(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _float32(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float32"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _float64(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float64"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _int32(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "int32"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _uint32(Class, params) {
+  return new Class(_objectSpread({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "uint32"
+  }, util.normalizeParams(params)));
+}
+
+// Boolean
+
+// @__NO_SIDE_EFFECTS__
+export function _boolean(Class, params) {
+  return new Class(_objectSpread({
+    type: "boolean"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedBoolean(Class, params) {
+  return new Class(_objectSpread({
+    type: "boolean",
+    coerce: true
+  }, util.normalizeParams(params)));
+}
+
+// BigInt
+
+// @__NO_SIDE_EFFECTS__
+export function _bigint(Class, params) {
+  return new Class(_objectSpread({
+    type: "bigint"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedBigint(Class, params) {
+  return new Class(_objectSpread({
+    type: "bigint",
+    coerce: true
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _int64(Class, params) {
+  return new Class(_objectSpread({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "int64"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _uint64(Class, params) {
+  return new Class(_objectSpread({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "uint64"
+  }, util.normalizeParams(params)));
+}
+
+// Symbol
+
+// @__NO_SIDE_EFFECTS__
+export function _symbol(Class, params) {
+  return new Class(_objectSpread({
+    type: "symbol"
+  }, util.normalizeParams(params)));
+}
+
+// Undefined
+
+// @__NO_SIDE_EFFECTS__
+export function _undefined(Class, params) {
+  return new Class(_objectSpread({
+    type: "undefined"
+  }, util.normalizeParams(params)));
+}
+
+// Null
+
+// @__NO_SIDE_EFFECTS__
+export function _null(Class, params) {
+  return new Class(_objectSpread({
+    type: "null"
+  }, util.normalizeParams(params)));
+}
+
+// Any
+
+// @__NO_SIDE_EFFECTS__
+export function _any(Class) {
+  return new Class({
+    type: "any"
+  });
+}
+
+// Unknown
+
+// @__NO_SIDE_EFFECTS__
+export function _unknown(Class) {
+  return new Class({
+    type: "unknown"
+  });
+}
+
+// Never
+
+// @__NO_SIDE_EFFECTS__
+export function _never(Class, params) {
+  return new Class(_objectSpread({
+    type: "never"
+  }, util.normalizeParams(params)));
+}
+
+// Void
+
+// @__NO_SIDE_EFFECTS__
+export function _void(Class, params) {
+  return new Class(_objectSpread({
+    type: "void"
+  }, util.normalizeParams(params)));
+}
+
+// Date
+
+// @__NO_SIDE_EFFECTS__
+export function _date(Class, params) {
+  return new Class(_objectSpread({
+    type: "date"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedDate(Class, params) {
+  return new Class(_objectSpread({
+    type: "date",
+    coerce: true
+  }, util.normalizeParams(params)));
+}
+
+// NaN
+
+// @__NO_SIDE_EFFECTS__
+export function _nan(Class, params) {
+  return new Class(_objectSpread({
+    type: "nan"
+  }, util.normalizeParams(params)));
+}
+
+// export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort" | "when">;
+
+// @__NO_SIDE_EFFECTS__
+export function _lt(value, params) {
+  return new checks.$ZodCheckLessThan(_objectSpread(_objectSpread({
+    check: "less_than"
+  }, util.normalizeParams(params)), {}, {
+    value,
+    inclusive: false
+  }));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _lte(value, params) {
+  return new checks.$ZodCheckLessThan(_objectSpread(_objectSpread({
+    check: "less_than"
+  }, util.normalizeParams(params)), {}, {
+    value,
+    inclusive: true
+  }));
+}
+export { /** @deprecated Use `z.lte()` instead. */
+_lte as _max };
+
+// ZodCheckGreaterThan
+
+// @__NO_SIDE_EFFECTS__
+export function _gt(value, params) {
+  return new checks.$ZodCheckGreaterThan(_objectSpread(_objectSpread({
+    check: "greater_than"
+  }, util.normalizeParams(params)), {}, {
+    value,
+    inclusive: false
+  }));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _gte(value, params) {
+  return new checks.$ZodCheckGreaterThan(_objectSpread(_objectSpread({
+    check: "greater_than"
+  }, util.normalizeParams(params)), {}, {
+    value,
+    inclusive: true
+  }));
+}
+export { /** @deprecated Use `z.gte()` instead. */
+_gte as _min };
+
+// @__NO_SIDE_EFFECTS__
+export function _positive(params) {
+  return _gt(0, params);
+}
+
+// negative
+// @__NO_SIDE_EFFECTS__
+export function _negative(params) {
+  return _lt(0, params);
+}
+
+// nonpositive
+// @__NO_SIDE_EFFECTS__
+export function _nonpositive(params) {
+  return _lte(0, params);
+}
+
+// nonnegative
+// @__NO_SIDE_EFFECTS__
+export function _nonnegative(params) {
+  return _gte(0, params);
+}
+// @__NO_SIDE_EFFECTS__
+export function _multipleOf(value, params) {
+  return new checks.$ZodCheckMultipleOf(_objectSpread(_objectSpread({
+    check: "multiple_of"
+  }, util.normalizeParams(params)), {}, {
+    value
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _maxSize(maximum, params) {
+  return new checks.$ZodCheckMaxSize(_objectSpread(_objectSpread({
+    check: "max_size"
+  }, util.normalizeParams(params)), {}, {
+    maximum
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _minSize(minimum, params) {
+  return new checks.$ZodCheckMinSize(_objectSpread(_objectSpread({
+    check: "min_size"
+  }, util.normalizeParams(params)), {}, {
+    minimum
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _size(size, params) {
+  return new checks.$ZodCheckSizeEquals(_objectSpread(_objectSpread({
+    check: "size_equals"
+  }, util.normalizeParams(params)), {}, {
+    size
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _maxLength(maximum, params) {
+  const ch = new checks.$ZodCheckMaxLength(_objectSpread(_objectSpread({
+    check: "max_length"
+  }, util.normalizeParams(params)), {}, {
+    maximum
+  }));
+  return ch;
+}
+// @__NO_SIDE_EFFECTS__
+export function _minLength(minimum, params) {
+  return new checks.$ZodCheckMinLength(_objectSpread(_objectSpread({
+    check: "min_length"
+  }, util.normalizeParams(params)), {}, {
+    minimum
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _length(length, params) {
+  return new checks.$ZodCheckLengthEquals(_objectSpread(_objectSpread({
+    check: "length_equals"
+  }, util.normalizeParams(params)), {}, {
+    length
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _regex(pattern, params) {
+  return new checks.$ZodCheckRegex(_objectSpread(_objectSpread({
+    check: "string_format",
+    format: "regex"
+  }, util.normalizeParams(params)), {}, {
+    pattern
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _lowercase(params) {
+  return new checks.$ZodCheckLowerCase(_objectSpread({
+    check: "string_format",
+    format: "lowercase"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _uppercase(params) {
+  return new checks.$ZodCheckUpperCase(_objectSpread({
+    check: "string_format",
+    format: "uppercase"
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _includes(includes, params) {
+  return new checks.$ZodCheckIncludes(_objectSpread(_objectSpread({
+    check: "string_format",
+    format: "includes"
+  }, util.normalizeParams(params)), {}, {
+    includes
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _startsWith(prefix, params) {
+  return new checks.$ZodCheckStartsWith(_objectSpread(_objectSpread({
+    check: "string_format",
+    format: "starts_with"
+  }, util.normalizeParams(params)), {}, {
+    prefix
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _endsWith(suffix, params) {
+  return new checks.$ZodCheckEndsWith(_objectSpread(_objectSpread({
+    check: "string_format",
+    format: "ends_with"
+  }, util.normalizeParams(params)), {}, {
+    suffix
+  }));
+}
+// @__NO_SIDE_EFFECTS__
+export function _property(property, schema, params) {
+  return new checks.$ZodCheckProperty(_objectSpread({
+    check: "property",
+    property,
+    schema
+  }, util.normalizeParams(params)));
+}
+// @__NO_SIDE_EFFECTS__
+export function _mime(types, params) {
+  return new checks.$ZodCheckMimeType(_objectSpread({
+    check: "mime_type",
+    mime: types
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _overwrite(tx) {
+  return new checks.$ZodCheckOverwrite({
+    check: "overwrite",
+    tx
+  });
+}
+// normalize
+// @__NO_SIDE_EFFECTS__
+export function _normalize(form) {
+  return _overwrite(input => input.normalize(form));
+}
+
+// trim
+// @__NO_SIDE_EFFECTS__
+export function _trim() {
+  return _overwrite(input => input.trim());
+}
+// toLowerCase
+// @__NO_SIDE_EFFECTS__
+export function _toLowerCase() {
+  return _overwrite(input => input.toLowerCase());
+}
+// toUpperCase
+// @__NO_SIDE_EFFECTS__
+export function _toUpperCase() {
+  return _overwrite(input => input.toUpperCase());
+}
+// slugify
+// @__NO_SIDE_EFFECTS__
+export function _slugify() {
+  return _overwrite(input => util.slugify(input));
+}
+
+///////  collections   ///////
+
+// Array
+
+// @__NO_SIDE_EFFECTS__
+export function _array(Class, element, params) {
+  return new Class(_objectSpread({
+    type: "array",
+    element
+  }, util.normalizeParams(params)));
+}
+
+// ZodUnion
+
+// @__NO_SIDE_EFFECTS__
+export function _union(Class, options, params) {
+  return new Class(_objectSpread({
+    type: "union",
+    options
+  }, util.normalizeParams(params)));
+}
+
+// ZodXor
+
+export function _xor(Class, options, params) {
+  return new Class(_objectSpread({
+    type: "union",
+    options,
+    inclusive: false
+  }, util.normalizeParams(params)));
+}
+
+// ZodDiscriminatedUnion
+
+// @__NO_SIDE_EFFECTS__
+export function _discriminatedUnion(Class, discriminator, options, params) {
+  return new Class(_objectSpread({
+    type: "union",
+    options,
+    discriminator
+  }, util.normalizeParams(params)));
+}
+
+// ZodIntersection
+
+// @__NO_SIDE_EFFECTS__
+export function _intersection(Class, left, right) {
+  return new Class({
+    type: "intersection",
+    left,
+    right
+  });
+}
+
+// ZodTuple
+
+// @__NO_SIDE_EFFECTS__
+
+// @__NO_SIDE_EFFECTS__
+
+// export function _tuple(
+//   Class: util.SchemaClass<schemas.$ZodTuple>,
+//   items: [],
+//   params?: string | $ZodTupleParams
+// ): schemas.$ZodTuple<[], null>;
+// @__NO_SIDE_EFFECTS__
+export function _tuple(Class, items, _paramsOrRest, _params) {
+  const hasRest = _paramsOrRest instanceof schemas.$ZodType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new Class(_objectSpread({
+    type: "tuple",
+    items,
+    rest
+  }, util.normalizeParams(params)));
+}
+
+// ZodRecord
+
+// @__NO_SIDE_EFFECTS__
+export function _record(Class, keyType, valueType, params) {
+  return new Class(_objectSpread({
+    type: "record",
+    keyType,
+    valueType
+  }, util.normalizeParams(params)));
+}
+
+// ZodMap
+
+// @__NO_SIDE_EFFECTS__
+export function _map(Class, keyType, valueType, params) {
+  return new Class(_objectSpread({
+    type: "map",
+    keyType,
+    valueType
+  }, util.normalizeParams(params)));
+}
+
+// ZodSet
+
+// @__NO_SIDE_EFFECTS__
+export function _set(Class, valueType, params) {
+  return new Class(_objectSpread({
+    type: "set",
+    valueType
+  }, util.normalizeParams(params)));
+}
+
+// ZodEnum
+
+// @__NO_SIDE_EFFECTS__
+
+// @__NO_SIDE_EFFECTS__
+
+// @__NO_SIDE_EFFECTS__
+export function _enum(Class, values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map(v => [v, v])) : values;
+  // if (Array.isArray(values)) {
+  //   for (const value of values) {
+  //     entries[value] = value;
+  //   }
+  // } else {
+  //   Object.assign(entries, values);
+  // }
+  // const entries: util.EnumLike = {};
+  // for (const val of values) {
+  //   entries[val] = val;
+  // }
+
+  return new Class(_objectSpread({
+    type: "enum",
+    entries
+  }, util.normalizeParams(params)));
+}
+
+// @__NO_SIDE_EFFECTS__
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export function _nativeEnum(Class, entries, params) {
+  return new Class(_objectSpread({
+    type: "enum",
+    entries
+  }, util.normalizeParams(params)));
+}
+
+// ZodLiteral
+
+// @__NO_SIDE_EFFECTS__
+export function _literal(Class, value, params) {
+  return new Class(_objectSpread({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value]
+  }, util.normalizeParams(params)));
+}
+
+// ZodFile
+
+// @__NO_SIDE_EFFECTS__
+export function _file(Class, params) {
+  return new Class(_objectSpread({
+    type: "file"
+  }, util.normalizeParams(params)));
+}
+
+// ZodTransform
+
+// @__NO_SIDE_EFFECTS__
+export function _transform(Class, fn) {
+  return new Class({
+    type: "transform",
+    transform: fn
+  });
+}
+
+// ZodOptional
+
+// @__NO_SIDE_EFFECTS__
+export function _optional(Class, innerType) {
+  return new Class({
+    type: "optional",
+    innerType
+  });
+}
+
+// ZodNullable
+
+// @__NO_SIDE_EFFECTS__
+export function _nullable(Class, innerType) {
+  return new Class({
+    type: "nullable",
+    innerType
+  });
+}
+
+// ZodDefault
+
+// @__NO_SIDE_EFFECTS__
+export function _default(Class, innerType, defaultValue) {
+  return new Class({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
+    }
+  });
+}
+
+// ZodNonOptional
+
+// @__NO_SIDE_EFFECTS__
+export function _nonoptional(Class, innerType, params) {
+  return new Class(_objectSpread({
+    type: "nonoptional",
+    innerType
+  }, util.normalizeParams(params)));
+}
+
+// ZodSuccess
+
+// @__NO_SIDE_EFFECTS__
+export function _success(Class, innerType) {
+  return new Class({
+    type: "success",
+    innerType
+  });
+}
+
+// ZodCatch
+
+// @__NO_SIDE_EFFECTS__
+export function _catch(Class, innerType, catchValue) {
+  return new Class({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+
+// ZodPipe
+
+// @__NO_SIDE_EFFECTS__
+export function _pipe(Class, in_, out) {
+  return new Class({
+    type: "pipe",
+    in: in_,
+    out
+  });
+}
+
+// ZodReadonly
+
+// @__NO_SIDE_EFFECTS__
+export function _readonly(Class, innerType) {
+  return new Class({
+    type: "readonly",
+    innerType
+  });
+}
+
+// ZodTemplateLiteral
+
+// @__NO_SIDE_EFFECTS__
+export function _templateLiteral(Class, parts, params) {
+  return new Class(_objectSpread({
+    type: "template_literal",
+    parts
+  }, util.normalizeParams(params)));
+}
+
+// ZodLazy
+
+// @__NO_SIDE_EFFECTS__
+export function _lazy(Class, getter) {
+  return new Class({
+    type: "lazy",
+    getter
+  });
+}
+
+// ZodPromise
+
+// @__NO_SIDE_EFFECTS__
+export function _promise(Class, innerType) {
+  return new Class({
+    type: "promise",
+    innerType
+  });
+}
+
+// ZodCustom
+
+// @__NO_SIDE_EFFECTS__
+export function _custom(Class, fn, _params) {
+  const norm = util.normalizeParams(_params);
+  norm.abort ??= true; // default to abort:false
+  const schema = new Class(_objectSpread({
+    type: "custom",
+    check: "custom",
+    fn: fn
+  }, norm));
+  return schema;
+}
+
+// same as _custom but defaults to abort:false
+// @__NO_SIDE_EFFECTS__
+export function _refine(Class, fn, _params) {
+  const schema = new Class(_objectSpread({
+    type: "custom",
+    check: "custom",
+    fn: fn
+  }, util.normalizeParams(_params)));
+  return schema;
+}
+// @__NO_SIDE_EFFECTS__
+export function _superRefine(fn) {
+  const ch = _check(payload => {
+    payload.addIssue = issue => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
+      } else {
+        // for Zod 3 backwards compatibility
+        const _issue = issue;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ??= "custom";
+        _issue.input ??= payload.value;
+        _issue.inst ??= ch;
+        _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+    return fn(payload.value, payload);
+  });
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _check(fn, params) {
+  const ch = new checks.$ZodCheck(_objectSpread({
+    check: "custom"
+  }, util.normalizeParams(params)));
+  ch._zod.check = fn;
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function describe(description) {
+  const ch = new checks.$ZodCheck({
+    check: "describe"
+  });
+  ch._zod.onattach = [inst => {
+    var _registries$globalReg;
+    const existing = (_registries$globalReg = registries.globalRegistry.get(inst)) !== null && _registries$globalReg !== void 0 ? _registries$globalReg : {};
+    registries.globalRegistry.add(inst, _objectSpread(_objectSpread({}, existing), {}, {
+      description
+    }));
+  }];
+  ch._zod.check = () => {}; // no-op check
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function meta(metadata) {
+  const ch = new checks.$ZodCheck({
+    check: "meta"
+  });
+  ch._zod.onattach = [inst => {
+    var _registries$globalReg2;
+    const existing = (_registries$globalReg2 = registries.globalRegistry.get(inst)) !== null && _registries$globalReg2 !== void 0 ? _registries$globalReg2 : {};
+    registries.globalRegistry.add(inst, _objectSpread(_objectSpread({}, existing), metadata));
+  }];
+  ch._zod.check = () => {}; // no-op check
+  return ch;
+}
+
+// export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">
+
+/////////    STRINGBOOL   /////////
+
+// stringbool
+
+// @__NO_SIDE_EFFECTS__
+export function _stringbool(Classes, _params) {
+  var _params$truthy, _params$falsy, _Classes$Codec, _Classes$Boolean, _Classes$String;
+  const params = util.normalizeParams(_params);
+  let truthyArray = (_params$truthy = params.truthy) !== null && _params$truthy !== void 0 ? _params$truthy : ["true", "1", "yes", "on", "y", "enabled"];
+  let falsyArray = (_params$falsy = params.falsy) !== null && _params$falsy !== void 0 ? _params$falsy : ["false", "0", "no", "off", "n", "disabled"];
+  if (params.case !== "sensitive") {
+    truthyArray = truthyArray.map(v => typeof v === "string" ? v.toLowerCase() : v);
+    falsyArray = falsyArray.map(v => typeof v === "string" ? v.toLowerCase() : v);
+  }
+  const truthySet = new Set(truthyArray);
+  const falsySet = new Set(falsyArray);
+  const _Codec = (_Classes$Codec = Classes.Codec) !== null && _Classes$Codec !== void 0 ? _Classes$Codec : schemas.$ZodCodec;
+  const _Boolean = (_Classes$Boolean = Classes.Boolean) !== null && _Classes$Boolean !== void 0 ? _Classes$Boolean : schemas.$ZodBoolean;
+  const _String = (_Classes$String = Classes.String) !== null && _Classes$String !== void 0 ? _Classes$String : schemas.$ZodString;
+  const stringSchema = new _String({
+    type: "string",
+    error: params.error
+  });
+  const booleanSchema = new _Boolean({
+    type: "boolean",
+    error: params.error
+  });
+  const codec = new _Codec({
+    type: "pipe",
+    in: stringSchema,
+    out: booleanSchema,
+    transform: (input, payload) => {
+      let data = input;
+      if (params.case !== "sensitive") data = data.toLowerCase();
+      if (truthySet.has(data)) {
+        return true;
+      } else if (falsySet.has(data)) {
+        return false;
+      } else {
+        payload.issues.push({
+          code: "invalid_value",
+          expected: "stringbool",
+          values: [...truthySet, ...falsySet],
+          input: payload.value,
+          inst: codec,
+          continue: false
+        });
+        return {};
+      }
+    },
+    reverseTransform: input => {
+      if (input === true) {
+        return truthyArray[0] || "true";
+      } else {
+        return falsyArray[0] || "false";
+      }
+    },
+    error: params.error
+  });
+  return codec;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _stringFormat(Class, format, fnOrRegex) {
+  let _params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const params = util.normalizeParams(_params);
+  const def = _objectSpread(_objectSpread({}, util.normalizeParams(_params)), {}, {
+    check: "string_format",
+    type: "string",
+    format,
+    fn: typeof fnOrRegex === "function" ? fnOrRegex : val => fnOrRegex.test(val)
+  }, params);
+  if (fnOrRegex instanceof RegExp) {
+    def.pattern = fnOrRegex;
+  }
+  const inst = new Class(def);
+  return inst;
+}