@agwab/pi-workflow 0.1.0

package/node_modules/zod/src/v4/core/api.ts

@@ -0,0 +1,1594 @@
+import * as checks from "./checks.js";
+import type * as core from "./core.js";
+import type * as errors from "./errors.js";
+import * as schemas from "./schemas.js";
+import * as util from "./util.js";
+
+export type Params<
+  T extends schemas.$ZodType | checks.$ZodCheck,
+  IssueTypes extends errors.$ZodIssueBase,
+  OmitKeys extends keyof T["_zod"]["def"] = never,
+> = util.Flatten<
+  Partial<
+    util.EmptyToNever<
+      Omit<T["_zod"]["def"], OmitKeys> &
+        ([IssueTypes] extends [never]
+          ? {} // unknown
+          : {
+              error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;
+              /** @deprecated This parameter is deprecated. Use `error` instead. */
+              message?: string | undefined; // supported in Zod 3
+            })
+    >
+  >
+>;
+
+export type TypeParams<
+  T extends schemas.$ZodType = schemas.$ZodType & { _isst: never },
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never,
+> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+
+// strips types that are not exposed in the public factory
+// incl. `error`, `check`
+export type CheckParams<
+  T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never,
+> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+
+// strips types that are not exposed in the public factory
+// incl. `type`, `checks`, `error`, `check`, `format`
+export type StringFormatParams<
+  T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat,
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never,
+> = Params<
+  T,
+  NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>,
+  "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit
+>;
+
+export type CheckStringFormatParams<
+  T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat,
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never,
+> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+
+export type CheckTypeParams<
+  T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck,
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never,
+> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+
+// String
+export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
+export function _string<T extends schemas.$ZodString>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodStringParams
+): T {
+  return new Class({
+    type: "string",
+    ...util.normalizeParams(params),
+  });
+}
+
+export function _coercedString<T extends schemas.$ZodString>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodStringParams
+): T {
+  return new Class({
+    type: "string",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
+export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
+// custom format
+
+// Email
+export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
+export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
+export function _email<T extends schemas.$ZodEmail>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodEmailParams | $ZodCheckEmailParams
+): T {
+  return new Class({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// GUID
+export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
+export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
+export function _guid<T extends schemas.$ZodGUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodGUIDParams | $ZodCheckGUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUID
+export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export function _uuid<T extends schemas.$ZodUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodUUIDParams | $ZodCheckUUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv4
+export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export function _uuidv4<T extends schemas.$ZodUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v4",
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv6
+export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export function _uuidv6<T extends schemas.$ZodUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v6",
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv7
+export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export function _uuidv7<T extends schemas.$ZodUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v7",
+    ...util.normalizeParams(params),
+  });
+}
+
+// URL
+export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
+export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
+export function _url<T extends schemas.$ZodURL>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodURLParams | $ZodCheckURLParams
+): T {
+  return new Class({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// Emoji
+export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
+export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
+export function _emoji<T extends schemas.$ZodEmoji>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodEmojiParams | $ZodCheckEmojiParams
+): T {
+  return new Class({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// NanoID
+export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
+export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
+export function _nanoid<T extends schemas.$ZodNanoID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CUID
+export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
+export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
+export function _cuid<T extends schemas.$ZodCUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCUIDParams | $ZodCheckCUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CUID2
+export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
+export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
+export function _cuid2<T extends schemas.$ZodCUID2>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCUID2Params | $ZodCheckCUID2Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ULID
+export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
+export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
+export function _ulid<T extends schemas.$ZodULID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodULIDParams | $ZodCheckULIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// XID
+export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
+export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
+export function _xid<T extends schemas.$ZodXID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodXIDParams | $ZodCheckXIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// KSUID
+export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
+export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
+export function _ksuid<T extends schemas.$ZodKSUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IP
+// export type $ZodIPParams = StringFormatParams<schemas.$ZodIP, "pattern">;
+// export type $ZodCheckIPParams = CheckStringFormatParams<schemas.$ZodIP, "pattern">;
+// export function _ip<T extends schemas.$ZodIP>(
+//   Class: util.SchemaClass<T>,
+//   params?: string | $ZodIPParams | $ZodCheckIPParams
+// ): T {
+//   return new Class({
+//     type: "string",
+//     format: "ip",
+//     check: "string_format",
+//     abort: false,
+//     ...util.normalizeParams(params),
+//   });
+// }
+
+// IPv4
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
+export function _ipv4<T extends schemas.$ZodIPv4>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodIPv4Params | $ZodCheckIPv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IPv6
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
+export function _ipv6<T extends schemas.$ZodIPv6>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodIPv6Params | $ZodCheckIPv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CIDRv4
+export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
+export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
+export function _cidrv4<T extends schemas.$ZodCIDRv4>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CIDRv6
+export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
+export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
+export function _cidrv6<T extends schemas.$ZodCIDRv6>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// Base64
+export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
+export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
+export function _base64<T extends schemas.$ZodBase64>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBase64Params | $ZodCheckBase64Params
+): T {
+  return new Class({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// base64url
+export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
+export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
+export function _base64url<T extends schemas.$ZodBase64URL>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams
+): T {
+  return new Class({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// E164
+export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
+export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
+export function _e164<T extends schemas.$ZodE164>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodE164Params | $ZodCheckE164Params
+): T {
+  return new Class({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// JWT
+export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
+export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
+export function _jwt<T extends schemas.$ZodJWT>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodJWTParams | $ZodCheckJWTParams
+): T {
+  return new Class({
+    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,
+} as const;
+// ISODateTime
+export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
+export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
+export function _isoDateTime<T extends schemas.$ZodISODateTime>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams
+): T {
+  return new Class({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: false,
+    local: false,
+    precision: null,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISODate
+export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
+export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
+export function _isoDate<T extends schemas.$ZodISODate>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodISODateParams | $ZodCheckISODateParams
+): T {
+  return new Class({
+    type: "string",
+    format: "date",
+    check: "string_format",
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISOTime
+export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
+export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
+export function _isoTime<T extends schemas.$ZodISOTime>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams
+): T {
+  return new Class({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISODuration
+export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
+export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
+export function _isoDuration<T extends schemas.$ZodISODuration>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodISODurationParams | $ZodCheckISODurationParams
+): T {
+  return new Class({
+    type: "string",
+    format: "duration",
+    check: "string_format",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Number
+export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
+export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
+export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
+export function _number<T extends schemas.$ZodNumber>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodNumberParams
+): T {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...util.normalizeParams(params),
+  });
+}
+
+export function _coercedNumber<T extends schemas.$ZodNumber>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodNumberParams
+): T {
+  return new Class({
+    type: "number",
+    coerce: true,
+    checks: [],
+    ...util.normalizeParams(params),
+  });
+}
+
+export function _int<T extends schemas.$ZodNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint",
+    ...util.normalizeParams(params),
+  });
+}
+export function _float32<T extends schemas.$ZodNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float32",
+    ...util.normalizeParams(params),
+  });
+}
+export function _float64<T extends schemas.$ZodNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float64",
+    ...util.normalizeParams(params),
+  });
+}
+export function _int32<T extends schemas.$ZodNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "int32",
+    ...util.normalizeParams(params),
+  });
+}
+export function _uint32<T extends schemas.$ZodNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "uint32",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Boolean
+export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
+export function _boolean<T extends schemas.$ZodBoolean>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBooleanParams
+): T {
+  return new Class({
+    type: "boolean",
+    ...util.normalizeParams(params),
+  });
+}
+export function _coercedBoolean<T extends schemas.$ZodBoolean>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBooleanParams
+): T {
+  return new Class({
+    type: "boolean",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+// BigInt
+export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
+export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
+export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
+export function _bigint<T extends schemas.$ZodBigInt>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBigIntParams
+): T {
+  return new Class({
+    type: "bigint",
+    ...util.normalizeParams(params),
+  });
+}
+export function _coercedBigint<T extends schemas.$ZodBigInt>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBigIntParams
+): T {
+  return new Class({
+    type: "bigint",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+export function _int64<T extends schemas.$ZodBigIntFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBigIntFormatParams
+): T {
+  return new Class({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "int64",
+    ...util.normalizeParams(params),
+  });
+}
+export function _uint64<T extends schemas.$ZodBigIntFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodBigIntFormatParams
+): T {
+  return new Class({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "uint64",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Symbol
+export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
+export function _symbol<T extends schemas.$ZodSymbol>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodSymbolParams
+): T {
+  return new Class({
+    type: "symbol",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Undefined
+export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
+export function _undefined<T extends schemas.$ZodUndefined>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodUndefinedParams
+): T {
+  return new Class({
+    type: "undefined",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Null
+export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
+export function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T {
+  return new Class({
+    type: "null",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Any
+export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
+export function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T {
+  return new Class({
+    type: "any",
+  });
+}
+
+// Unknown
+export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
+export function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T {
+  return new Class({
+    type: "unknown",
+  });
+}
+
+// Never
+export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
+export function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T {
+  return new Class({
+    type: "never",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Void
+export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
+export function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T {
+  return new Class({
+    type: "void",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Date
+export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
+export function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T {
+  return new Class({
+    type: "date",
+    ...util.normalizeParams(params),
+  });
+}
+export function _coercedDate<T extends schemas.$ZodDate>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodDateParams
+): T {
+  return new Class({
+    type: "date",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+// NaN
+export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
+export function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T {
+  return new Class({
+    type: "nan",
+    ...util.normalizeParams(params),
+  });
+}
+
+// export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort">;
+
+export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
+export function _lt(
+  value: util.Numeric,
+  params?: string | $ZodCheckLessThanParams
+): checks.$ZodCheckLessThan<util.Numeric> {
+  return new checks.$ZodCheckLessThan({
+    check: "less_than",
+    ...util.normalizeParams(params),
+    value,
+    inclusive: false,
+  });
+}
+
+export function _lte(
+  value: util.Numeric,
+  params?: string | $ZodCheckLessThanParams
+): checks.$ZodCheckLessThan<util.Numeric> {
+  return new checks.$ZodCheckLessThan({
+    check: "less_than",
+
+    ...util.normalizeParams(params),
+    value,
+    inclusive: true,
+  });
+}
+export {
+  /** @deprecated Use `z.lte()` instead. */
+  _lte as _max,
+};
+
+// ZodCheckGreaterThan
+export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
+export function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
+  return new checks.$ZodCheckGreaterThan({
+    check: "greater_than",
+
+    ...util.normalizeParams(params),
+    value,
+    inclusive: false,
+  });
+}
+
+export function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
+  return new checks.$ZodCheckGreaterThan({
+    check: "greater_than",
+    ...util.normalizeParams(params),
+    value,
+    inclusive: true,
+  });
+}
+
+export {
+  /** @deprecated Use `z.gte()` instead. */
+  _gte as _min,
+};
+
+export function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
+  return _gt(0, params);
+}
+
+// negative
+export function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan {
+  return _lt(0, params);
+}
+
+// nonpositive
+export function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan {
+  return _lte(0, params);
+}
+
+// nonnegative
+export function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
+  return _gte(0, params);
+}
+
+export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
+export function _multipleOf(
+  value: number | bigint,
+  params?: string | $ZodCheckMultipleOfParams
+): checks.$ZodCheckMultipleOf {
+  return new checks.$ZodCheckMultipleOf({
+    check: "multiple_of",
+    ...util.normalizeParams(params),
+    value,
+  });
+}
+
+export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
+export function _maxSize(
+  maximum: number,
+  params?: string | $ZodCheckMaxSizeParams
+): checks.$ZodCheckMaxSize<util.HasSize> {
+  return new checks.$ZodCheckMaxSize({
+    check: "max_size",
+    ...util.normalizeParams(params),
+    maximum,
+  });
+}
+
+export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
+export function _minSize(
+  minimum: number,
+  params?: string | $ZodCheckMinSizeParams
+): checks.$ZodCheckMinSize<util.HasSize> {
+  return new checks.$ZodCheckMinSize({
+    check: "min_size",
+    ...util.normalizeParams(params),
+    minimum,
+  });
+}
+
+export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
+export function _size(
+  size: number,
+  params?: string | $ZodCheckSizeEqualsParams
+): checks.$ZodCheckSizeEquals<util.HasSize> {
+  return new checks.$ZodCheckSizeEquals({
+    check: "size_equals",
+    ...util.normalizeParams(params),
+    size,
+  });
+}
+
+export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
+export function _maxLength(
+  maximum: number,
+  params?: string | $ZodCheckMaxLengthParams
+): checks.$ZodCheckMaxLength<util.HasLength> {
+  const ch = new checks.$ZodCheckMaxLength({
+    check: "max_length",
+    ...util.normalizeParams(params),
+    maximum,
+  });
+  return ch;
+}
+
+export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
+export function _minLength(
+  minimum: number,
+  params?: string | $ZodCheckMinLengthParams
+): checks.$ZodCheckMinLength<util.HasLength> {
+  return new checks.$ZodCheckMinLength({
+    check: "min_length",
+    ...util.normalizeParams(params),
+    minimum,
+  });
+}
+
+export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
+export function _length(
+  length: number,
+  params?: string | $ZodCheckLengthEqualsParams
+): checks.$ZodCheckLengthEquals<util.HasLength> {
+  return new checks.$ZodCheckLengthEquals({
+    check: "length_equals",
+    ...util.normalizeParams(params),
+    length,
+  });
+}
+
+export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
+export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex {
+  return new checks.$ZodCheckRegex({
+    check: "string_format",
+    format: "regex",
+    ...util.normalizeParams(params),
+    pattern,
+  });
+}
+
+export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
+export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase {
+  return new checks.$ZodCheckLowerCase({
+    check: "string_format",
+    format: "lowercase",
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
+
+export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase {
+  return new checks.$ZodCheckUpperCase({
+    check: "string_format",
+    format: "uppercase",
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
+export function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes {
+  return new checks.$ZodCheckIncludes({
+    check: "string_format",
+    format: "includes",
+    ...util.normalizeParams(params),
+    includes,
+  });
+}
+export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
+export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith {
+  return new checks.$ZodCheckStartsWith({
+    check: "string_format",
+    format: "starts_with",
+    ...util.normalizeParams(params),
+    prefix,
+  });
+}
+
+export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
+
+export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith {
+  return new checks.$ZodCheckEndsWith({
+    check: "string_format",
+    format: "ends_with",
+    ...util.normalizeParams(params),
+    suffix,
+  });
+}
+
+export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
+export function _property<K extends string, T extends schemas.$ZodType>(
+  property: K,
+  schema: T,
+  params?: string | $ZodCheckPropertyParams
+): checks.$ZodCheckProperty<{ [k in K]: core.output<T> }> {
+  return new checks.$ZodCheckProperty({
+    check: "property",
+    property,
+    schema,
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
+export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType {
+  return new checks.$ZodCheckMimeType({
+    check: "mime_type",
+    mime: types,
+    ...util.normalizeParams(params),
+  });
+}
+
+export function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T> {
+  return new checks.$ZodCheckOverwrite({
+    check: "overwrite",
+    tx,
+  }) as checks.$ZodCheckOverwrite<T>;
+}
+// normalize
+export function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string> {
+  return _overwrite((input) => input.normalize(form));
+}
+
+// trim
+export function _trim(): checks.$ZodCheckOverwrite<string> {
+  return _overwrite((input) => input.trim());
+}
+// toLowerCase
+export function _toLowerCase(): checks.$ZodCheckOverwrite<string> {
+  return _overwrite((input) => input.toLowerCase());
+}
+// toUpperCase
+export function _toUpperCase(): checks.$ZodCheckOverwrite<string> {
+  return _overwrite((input) => input.toUpperCase());
+}
+
+///////  collections   ///////
+
+// Array
+export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
+export function _array<T extends schemas.$ZodType>(
+  Class: util.SchemaClass<schemas.$ZodArray>,
+  element: T,
+  params?: string | $ZodArrayParams
+): schemas.$ZodArray<T> {
+  return new Class({
+    type: "array",
+    element,
+    // get element() {
+    //   return element;
+    // },
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
+
+// ZodUnion
+export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
+export function _union<const T extends readonly schemas.$ZodObject[]>(
+  Class: util.SchemaClass<schemas.$ZodUnion>,
+  options: T,
+  params?: string | $ZodUnionParams
+): schemas.$ZodUnion<T> {
+  return new Class({
+    type: "union",
+    options,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodDiscriminatedUnion
+export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
+  propValues: util.PropValues;
+}
+
+export interface $ZodTypeDiscriminable extends schemas.$ZodType {
+  _zod: $ZodTypeDiscriminableInternals;
+}
+export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
+export function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(
+  Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>,
+  discriminator: string,
+  options: Types,
+  params?: string | $ZodDiscriminatedUnionParams
+): schemas.$ZodDiscriminatedUnion<Types> {
+  return new Class({
+    type: "union",
+    options,
+    discriminator,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodIntersection
+export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
+export function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodIntersection>,
+  left: T,
+  right: U
+): schemas.$ZodIntersection<T, U> {
+  return new Class({
+    type: "intersection",
+    left,
+    right,
+  }) as any;
+}
+
+// ZodTuple
+export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
+export function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(
+  Class: util.SchemaClass<schemas.$ZodTuple>,
+  items: T,
+  params?: string | $ZodTupleParams
+): schemas.$ZodTuple<T, null>;
+export function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(
+  Class: util.SchemaClass<schemas.$ZodTuple>,
+  items: T,
+  rest: Rest,
+  params?: string | $ZodTupleParams
+): schemas.$ZodTuple<T, Rest>;
+// export function _tuple(
+//   Class: util.SchemaClass<schemas.$ZodTuple>,
+//   items: [],
+//   params?: string | $ZodTupleParams
+// ): schemas.$ZodTuple<[], null>;
+export function _tuple(
+  Class: util.SchemaClass<schemas.$ZodTuple>,
+  items: schemas.$ZodType[],
+  _paramsOrRest?: string | $ZodTupleParams | schemas.$ZodType,
+  _params?: string | $ZodTupleParams
+) {
+  const hasRest = _paramsOrRest instanceof schemas.$ZodType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new Class({
+    type: "tuple",
+    items,
+    rest,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ZodRecord
+export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
+export function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodRecord>,
+  keyType: Key,
+  valueType: Value,
+  params?: string | $ZodRecordParams
+): schemas.$ZodRecord<Key, Value> {
+  return new Class({
+    type: "record",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodMap
+export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
+export function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodMap>,
+  keyType: Key,
+  valueType: Value,
+  params?: string | $ZodMapParams
+): schemas.$ZodMap<Key, Value> {
+  return new Class({
+    type: "map",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodSet
+export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
+export function _set<Value extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodSet>,
+  valueType: Value,
+  params?: string | $ZodSetParams
+): schemas.$ZodSet<Value> {
+  return new Class({
+    type: "set",
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodEnum
+export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
+export function _enum<const T extends string[]>(
+  Class: util.SchemaClass<schemas.$ZodEnum>,
+  values: T,
+  params?: string | $ZodEnumParams
+): schemas.$ZodEnum<util.ToEnum<T[number]>>;
+export function _enum<T extends util.EnumLike>(
+  Class: util.SchemaClass<schemas.$ZodEnum>,
+  entries: T,
+  params?: string | $ZodEnumParams
+): schemas.$ZodEnum<T>;
+export function _enum(Class: util.SchemaClass<schemas.$ZodEnum>, values: any, params?: string | $ZodEnumParams) {
+  const entries: any = 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({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+/** @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<T extends util.EnumLike>(
+  Class: util.SchemaClass<schemas.$ZodEnum>,
+  entries: T,
+  params?: string | $ZodEnumParams
+): schemas.$ZodEnum<T> {
+  return new Class({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodLiteral
+export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
+export function _literal<const T extends Array<util.Literal>>(
+  Class: util.SchemaClass<schemas.$ZodLiteral>,
+  value: T,
+  params?: string | $ZodLiteralParams
+): schemas.$ZodLiteral<T[number]>;
+export function _literal<const T extends util.Literal>(
+  Class: util.SchemaClass<schemas.$ZodLiteral>,
+  value: T,
+  params?: string | $ZodLiteralParams
+): schemas.$ZodLiteral<T>;
+export function _literal(Class: util.SchemaClass<schemas.$ZodLiteral>, value: any, params: any) {
+  return new Class({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(params),
+  });
+}
+
+// ZodFile
+export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
+export function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile {
+  return new Class({
+    type: "file",
+    ...util.normalizeParams(params),
+  });
+}
+
+// ZodTransform
+export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
+export function _transform<I = unknown, O = I>(
+  Class: util.SchemaClass<schemas.$ZodTransform>,
+  fn: (input: I, ctx?: schemas.ParsePayload) => O
+): schemas.$ZodTransform<Awaited<O>, I> {
+  return new Class({
+    type: "transform",
+    transform: fn as any,
+  }) as any;
+}
+
+// ZodOptional
+export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
+export function _optional<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodOptional>,
+  innerType: T
+): schemas.$ZodOptional<T> {
+  return new Class({
+    type: "optional",
+    innerType,
+  }) as any;
+}
+
+// ZodNullable
+export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
+export function _nullable<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodNullable>,
+  innerType: T
+): schemas.$ZodNullable<T> {
+  return new Class({
+    type: "nullable",
+    innerType,
+  }) as any;
+}
+
+// ZodDefault
+export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
+export function _default<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodDefault>,
+  innerType: T,
+  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)
+): schemas.$ZodDefault<T> {
+  return new Class({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue;
+    },
+  }) as any;
+}
+
+// ZodNonOptional
+export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
+export function _nonoptional<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodNonOptional>,
+  innerType: T,
+  params?: string | $ZodNonOptionalParams
+): schemas.$ZodNonOptional<T> {
+  return new Class({
+    type: "nonoptional",
+    innerType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodSuccess
+export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
+export function _success<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodSuccess>,
+  innerType: T
+): schemas.$ZodSuccess<T> {
+  return new Class({
+    type: "success",
+    innerType,
+  }) as any;
+}
+
+// ZodCatch
+export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
+export function _catch<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodCatch>,
+  innerType: T,
+  catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)
+): schemas.$ZodCatch<T> {
+  return new Class({
+    type: "catch",
+    innerType,
+    catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as any,
+  }) as any;
+}
+
+// ZodPipe
+export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
+export function _pipe<
+  const A extends schemas.$ZodType,
+  B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>,
+>(
+  Class: util.SchemaClass<schemas.$ZodPipe>,
+  in_: A,
+  out: B | schemas.$ZodType<unknown, core.output<A>>
+): schemas.$ZodPipe<A, B> {
+  return new Class({
+    type: "pipe",
+    in: in_,
+    out,
+  }) as any;
+}
+
+// ZodReadonly
+export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
+export function _readonly<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodReadonly>,
+  innerType: T
+): schemas.$ZodReadonly<T> {
+  return new Class({
+    type: "readonly",
+    innerType,
+  }) as any;
+}
+
+// ZodTemplateLiteral
+export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
+export function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(
+  Class: util.SchemaClass<schemas.$ZodTemplateLiteral>,
+  parts: Parts,
+  params?: string | $ZodTemplateLiteralParams
+): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>> {
+  return new Class({
+    type: "template_literal",
+    parts,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// ZodLazy
+export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
+export function _lazy<T extends schemas.$ZodType>(
+  Class: util.SchemaClass<schemas.$ZodLazy>,
+  getter: () => T
+): schemas.$ZodLazy<T> {
+  return new Class({
+    type: "lazy",
+    getter,
+  }) as any;
+}
+
+// ZodPromise
+export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
+export function _promise<T extends schemas.$ZodObject>(
+  Class: util.SchemaClass<schemas.$ZodPromise>,
+  innerType: T
+): schemas.$ZodPromise<T> {
+  return new Class({
+    type: "promise",
+    innerType,
+  }) as any;
+}
+
+// ZodCustom
+export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
+export function _custom<O = unknown, I = O>(
+  Class: util.SchemaClass<schemas.$ZodCustom>,
+  fn: (data: O) => unknown,
+  _params: string | $ZodCustomParams | undefined
+): schemas.$ZodCustom<O, I> {
+  const norm = util.normalizeParams(_params);
+  norm.abort ??= true; // default to abort:false
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn: fn as any,
+    ...norm,
+  });
+
+  return schema as any;
+}
+
+// export function _refine<T>(
+//   Class: util.SchemaClass<schemas.$ZodCustom>,
+//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
+//   _params: string | $ZodCustomParams = {}
+// ): checks.$ZodCheck<T> {
+//   return _custom(Class, fn, _params);
+// }
+// same as _custom but defaults to abort:false
+export function _refine<O = unknown, I = O>(
+  Class: util.SchemaClass<schemas.$ZodCustom>,
+  fn: (data: O) => unknown,
+  _params: string | $ZodCustomParams | undefined
+): schemas.$ZodCustom<O, I> {
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn: fn as any,
+    ...util.normalizeParams(_params),
+  });
+
+  return schema as any;
+}
+
+// export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">
+
+/////////    STRINGBOOL   /////////
+
+// stringbool
+export interface $ZodStringBoolParams extends TypeParams {
+  truthy?: string[];
+  falsy?: string[];
+  /**
+   * Options: `"sensitive"`, `"insensitive"`
+   *
+   * @default `"insensitive"`
+   */
+  case?: "sensitive" | "insensitive" | undefined;
+}
+
+export function _stringbool(
+  Classes: {
+    Pipe?: typeof schemas.$ZodPipe;
+    Boolean?: typeof schemas.$ZodBoolean;
+    Transform?: typeof schemas.$ZodTransform;
+    String?: typeof schemas.$ZodString;
+  },
+  _params?: string | $ZodStringBoolParams
+): schemas.$ZodPipe<
+  schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>,
+  schemas.$ZodBoolean<boolean>
+> {
+  const params = util.normalizeParams(_params);
+
+  let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+  let falsyArray = 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 _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
+  const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
+  const _String = Classes.String ?? schemas.$ZodString;
+  const _Transform = Classes.Transform ?? schemas.$ZodTransform;
+
+  const tx = new _Transform({
+    type: "transform",
+    transform: (input, payload: schemas.ParsePayload<unknown>) => {
+      let data: string = input as string;
+      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: tx,
+        });
+        return {} as never;
+      }
+    },
+    error: params.error,
+  });
+  // params.error;
+
+  const innerPipe = new _Pipe({
+    type: "pipe",
+    in: new _String({ type: "string", error: params.error }),
+    out: tx,
+    error: params.error,
+  });
+
+  const outerPipe = new _Pipe({
+    type: "pipe",
+    in: innerPipe,
+    out: new _Boolean({
+      type: "boolean",
+      error: params.error,
+    }),
+    error: params.error,
+  });
+  return outerPipe as any;
+}
+
+export function _stringFormat<Format extends string>(
+  Class: typeof schemas.$ZodCustomStringFormat,
+  format: Format,
+  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,
+  _params: string | $ZodStringFormatParams = {}
+): schemas.$ZodCustomStringFormat<Format> {
+  const params = util.normalizeParams(_params);
+  const def: schemas.$ZodCustomStringFormatDef = {
+    ...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 as any;
+}