@willaimg/yatsp 4.3.6

package/src/v4/core/api.ts

@@ -0,0 +1,1913 @@
+import * as checks from "./checks.js";
+import type * as core from "./core.js";
+import type * as errors from "./errors.js";
+import * as registries from "./registries.js";
+import * as schemas from "./schemas.js";
+import * as util from "./util.js";
+
+export type Params<
+  T extends schemas.$YatspType | checks.$YatspCheck,
+  IssueTypes extends errors.$YatspIssueBase,
+  OmitKeys extends keyof T["_yatsp"]["def"] = never,
+> = util.Flatten<
+  Partial<
+    util.EmptyToNever<
+      Omit<T["_yatsp"]["def"], OmitKeys> &
+        ([IssueTypes] extends [never]
+          ? {} // unknown
+          : {
+              error?: string | errors.$YatspErrorMap<IssueTypes> | undefined;
+              /** @deprecated This parameter is deprecated. Use `error` instead. */
+              message?: string | undefined; // supported in Yatsp 3
+            })
+    >
+  >
+>;
+
+export type TypeParams<
+  T extends schemas.$YatspType = schemas.$YatspType & { _isst: never },
+  AlsoOmit extends Exclude<keyof T["_yatsp"]["def"], "type" | "checks" | "error"> = never,
+> = Params<T, NonNullable<T["_yatsp"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+
+// strips types that are not exposed in the public factory
+// incl. `error`, `check`
+export type CheckParams<
+  T extends checks.$YatspCheck = checks.$YatspCheck, // & { _issc: never },
+  AlsoOmit extends Exclude<keyof T["_yatsp"]["def"], "check" | "error"> = never,
+> = Params<T, NonNullable<T["_yatsp"]["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.$YatspStringFormat = schemas.$YatspStringFormat,
+  AlsoOmit extends Exclude<
+    keyof T["_yatsp"]["def"],
+    "type" | "coerce" | "checks" | "error" | "check" | "format"
+  > = never,
+> = Params<
+  T,
+  NonNullable<T["_yatsp"]["isst"] | T["_yatsp"]["issc"]>,
+  "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit
+>;
+
+export type CheckStringFormatParams<
+  T extends schemas.$YatspStringFormat = schemas.$YatspStringFormat,
+  AlsoOmit extends Exclude<
+    keyof T["_yatsp"]["def"],
+    "type" | "coerce" | "checks" | "error" | "check" | "format"
+  > = never,
+> = Params<T, NonNullable<T["_yatsp"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+
+export type CheckTypeParams<
+  T extends schemas.$YatspType & checks.$YatspCheck = schemas.$YatspType & checks.$YatspCheck,
+  AlsoOmit extends Exclude<keyof T["_yatsp"]["def"], "type" | "checks" | "error" | "check"> = never,
+> = Params<T, NonNullable<T["_yatsp"]["isst"] | T["_yatsp"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+
+// String
+export type $YatspStringParams = TypeParams<schemas.$YatspString<string>, "coerce"> & {
+  checks?: readonly checks.$YatspCheck<string>[];
+};
+
+function snapshotChecks<T extends { checks?: readonly checks.$YatspCheck<never>[] }>(def: T) {
+  if (def.checks) def.checks = [...def.checks];
+  return def as T & { checks?: NonNullable<T["checks"]>[number][] };
+}
+// @__NO_SIDE_EFFECTS__
+export function _string<T extends schemas.$YatspString>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspStringParams
+): T {
+  return new Class(snapshotChecks({ type: "string" as const, ...util.normalizeParams(params) }));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _coercedString<T extends schemas.$YatspString>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspStringParams
+): T {
+  return new Class(snapshotChecks({ type: "string" as const, coerce: true, ...util.normalizeParams(params) }));
+}
+
+export type $YatspStringFormatParams = CheckTypeParams<
+  schemas.$YatspStringFormat,
+  "format" | "coerce" | "when" | "pattern"
+>;
+export type $YatspCheckStringFormatParams = CheckParams<checks.$YatspCheckStringFormat, "format">;
+// custom format
+
+// Email
+export type $YatspEmailParams = StringFormatParams<schemas.$YatspEmail, "when">;
+export type $YatspCheckEmailParams = CheckStringFormatParams<schemas.$YatspEmail, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _email<T extends schemas.$YatspEmail>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspEmailParams | $YatspCheckEmailParams
+): T {
+  return new Class({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// GUID
+export type $YatspGUIDParams = StringFormatParams<schemas.$YatspGUID, "pattern" | "when">;
+export type $YatspCheckGUIDParams = CheckStringFormatParams<schemas.$YatspGUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _guid<T extends schemas.$YatspGUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspGUIDParams | $YatspCheckGUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUID
+export type $YatspUUIDParams = StringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+export type $YatspCheckUUIDParams = CheckStringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _uuid<T extends schemas.$YatspUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspUUIDParams | $YatspCheckUUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv4
+export type $YatspUUIDv4Params = StringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+export type $YatspCheckUUIDv4Params = CheckStringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _uuidv4<T extends schemas.$YatspUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspUUIDv4Params | $YatspCheckUUIDv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v4",
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv6
+export type $YatspUUIDv6Params = StringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+export type $YatspCheckUUIDv6Params = CheckStringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _uuidv6<T extends schemas.$YatspUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspUUIDv6Params | $YatspCheckUUIDv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v6",
+    ...util.normalizeParams(params),
+  });
+}
+
+// UUIDv7
+export type $YatspUUIDv7Params = StringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+export type $YatspCheckUUIDv7Params = CheckStringFormatParams<schemas.$YatspUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _uuidv7<T extends schemas.$YatspUUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspUUIDv7Params | $YatspCheckUUIDv7Params
+): T {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v7",
+    ...util.normalizeParams(params),
+  });
+}
+
+// URL
+export type $YatspURLParams = StringFormatParams<schemas.$YatspURL, "when">;
+export type $YatspCheckURLParams = CheckStringFormatParams<schemas.$YatspURL, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _url<T extends schemas.$YatspURL>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspURLParams | $YatspCheckURLParams
+): T {
+  return new Class({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// Emoji
+export type $YatspEmojiParams = StringFormatParams<schemas.$YatspEmoji, "when">;
+export type $YatspCheckEmojiParams = CheckStringFormatParams<schemas.$YatspEmoji, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _emoji<T extends schemas.$YatspEmoji>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspEmojiParams | $YatspCheckEmojiParams
+): T {
+  return new Class({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// NanoID
+export type $YatspNanoIDParams = StringFormatParams<schemas.$YatspNanoID, "when" | "pattern">;
+export type $YatspCheckNanoIDParams = CheckStringFormatParams<schemas.$YatspNanoID, "when" | "pattern">;
+// @__NO_SIDE_EFFECTS__
+export function _nanoid<T extends schemas.$YatspNanoID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspNanoIDParams | $YatspCheckNanoIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CUID
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export type $YatspCUIDParams = StringFormatParams<schemas.$YatspCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export type $YatspCheckCUIDParams = CheckStringFormatParams<schemas.$YatspCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+// @__NO_SIDE_EFFECTS__
+export function _cuid<T extends schemas.$YatspCUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCUIDParams | $YatspCheckCUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CUID2
+export type $YatspCUID2Params = StringFormatParams<schemas.$YatspCUID2, "when">;
+export type $YatspCheckCUID2Params = CheckStringFormatParams<schemas.$YatspCUID2, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _cuid2<T extends schemas.$YatspCUID2>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCUID2Params | $YatspCheckCUID2Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ULID
+export type $YatspULIDParams = StringFormatParams<schemas.$YatspULID, "when">;
+export type $YatspCheckULIDParams = CheckStringFormatParams<schemas.$YatspULID, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _ulid<T extends schemas.$YatspULID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspULIDParams | $YatspCheckULIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// XID
+export type $YatspXIDParams = StringFormatParams<schemas.$YatspXID, "when">;
+export type $YatspCheckXIDParams = CheckStringFormatParams<schemas.$YatspXID, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _xid<T extends schemas.$YatspXID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspXIDParams | $YatspCheckXIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// KSUID
+export type $YatspKSUIDParams = StringFormatParams<schemas.$YatspKSUID, "when">;
+export type $YatspCheckKSUIDParams = CheckStringFormatParams<schemas.$YatspKSUID, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _ksuid<T extends schemas.$YatspKSUID>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspKSUIDParams | $YatspCheckKSUIDParams
+): T {
+  return new Class({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IPv4
+export type $YatspIPv4Params = StringFormatParams<schemas.$YatspIPv4, "pattern" | "when" | "version">;
+export type $YatspCheckIPv4Params = CheckStringFormatParams<schemas.$YatspIPv4, "pattern" | "when" | "version">;
+// @__NO_SIDE_EFFECTS__
+export function _ipv4<T extends schemas.$YatspIPv4>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspIPv4Params | $YatspCheckIPv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IPv6
+export type $YatspIPv6Params = StringFormatParams<schemas.$YatspIPv6, "pattern" | "when" | "version">;
+export type $YatspCheckIPv6Params = CheckStringFormatParams<schemas.$YatspIPv6, "pattern" | "when" | "version">;
+// @__NO_SIDE_EFFECTS__
+export function _ipv6<T extends schemas.$YatspIPv6>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspIPv6Params | $YatspCheckIPv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// MAC
+export type $YatspMACParams = StringFormatParams<schemas.$YatspMAC, "pattern" | "when">;
+export type $YatspCheckMACParams = CheckStringFormatParams<schemas.$YatspMAC, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _mac<T extends schemas.$YatspMAC>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspMACParams | $YatspCheckMACParams
+): T {
+  return new Class({
+    type: "string",
+    format: "mac",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CIDRv4
+export type $YatspCIDRv4Params = StringFormatParams<schemas.$YatspCIDRv4, "pattern" | "when">;
+export type $YatspCheckCIDRv4Params = CheckStringFormatParams<schemas.$YatspCIDRv4, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _cidrv4<T extends schemas.$YatspCIDRv4>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCIDRv4Params | $YatspCheckCIDRv4Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CIDRv6
+export type $YatspCIDRv6Params = StringFormatParams<schemas.$YatspCIDRv6, "pattern" | "when">;
+export type $YatspCheckCIDRv6Params = CheckStringFormatParams<schemas.$YatspCIDRv6, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _cidrv6<T extends schemas.$YatspCIDRv6>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCIDRv6Params | $YatspCheckCIDRv6Params
+): T {
+  return new Class({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// Base64
+export type $YatspBase64Params = StringFormatParams<schemas.$YatspBase64, "pattern" | "when">;
+export type $YatspCheckBase64Params = CheckStringFormatParams<schemas.$YatspBase64, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _base64<T extends schemas.$YatspBase64>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBase64Params | $YatspCheckBase64Params
+): T {
+  return new Class({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// base64url
+export type $YatspBase64URLParams = StringFormatParams<schemas.$YatspBase64URL, "pattern" | "when">;
+export type $YatspCheckBase64URLParams = CheckStringFormatParams<schemas.$YatspBase64URL, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _base64url<T extends schemas.$YatspBase64URL>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBase64URLParams | $YatspCheckBase64URLParams
+): T {
+  return new Class({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// E164
+export type $YatspE164Params = StringFormatParams<schemas.$YatspE164, "when">;
+export type $YatspCheckE164Params = CheckStringFormatParams<schemas.$YatspE164, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _e164<T extends schemas.$YatspE164>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspE164Params | $YatspCheckE164Params
+): T {
+  return new Class({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// CreditCard
+export type $YatspCreditCardParams = StringFormatParams<schemas.$YatspCreditCard, "pattern" | "when">;
+export type $YatspCheckCreditCardParams = CheckStringFormatParams<schemas.$YatspCreditCard, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _creditCard<T extends schemas.$YatspCreditCard>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCreditCardParams | $YatspCheckCreditCardParams
+): T {
+  return new Class({
+    type: "string",
+    format: "credit_card",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IBAN
+export type $YatspIBANParams = StringFormatParams<schemas.$YatspIBAN, "pattern" | "when">;
+export type $YatspCheckIBANParams = CheckStringFormatParams<schemas.$YatspIBAN, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _iban<T extends schemas.$YatspIBAN>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspIBANParams | $YatspCheckIBANParams
+): T {
+  return new Class({
+    type: "string",
+    format: "iban",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// JWT
+export type $YatspJWTParams = StringFormatParams<schemas.$YatspJWT, "pattern" | "when">;
+export type $YatspCheckJWTParams = CheckStringFormatParams<schemas.$YatspJWT, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _jwt<T extends schemas.$YatspJWT>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspJWTParams | $YatspCheckJWTParams
+): 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 $YatspISODateTimeParams = StringFormatParams<schemas.$YatspISODateTime, "pattern" | "when">;
+export type $YatspCheckISODateTimeParams = CheckStringFormatParams<schemas.$YatspISODateTime, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _isoDateTime<T extends schemas.$YatspISODateTime>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspISODateTimeParams | $YatspCheckISODateTimeParams
+): T {
+  return new Class({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: false,
+    local: false,
+    precision: null,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISODate
+export type $YatspISODateParams = StringFormatParams<schemas.$YatspISODate, "pattern" | "when">;
+export type $YatspCheckISODateParams = CheckStringFormatParams<schemas.$YatspISODate, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _isoDate<T extends schemas.$YatspISODate>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspISODateParams | $YatspCheckISODateParams
+): T {
+  return new Class({
+    type: "string",
+    format: "date",
+    check: "string_format",
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISOTime
+export type $YatspISOTimeParams = StringFormatParams<schemas.$YatspISOTime, "pattern" | "when">;
+export type $YatspCheckISOTimeParams = CheckStringFormatParams<schemas.$YatspISOTime, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _isoTime<T extends schemas.$YatspISOTime>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspISOTimeParams | $YatspCheckISOTimeParams
+): T {
+  return new Class({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null,
+    ...util.normalizeParams(params),
+  });
+}
+
+// ISODuration
+export type $YatspISODurationParams = StringFormatParams<schemas.$YatspISODuration, "when">;
+export type $YatspCheckISODurationParams = CheckStringFormatParams<schemas.$YatspISODuration, "when">;
+// @__NO_SIDE_EFFECTS__
+export function _isoDuration<T extends schemas.$YatspISODuration>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspISODurationParams | $YatspCheckISODurationParams
+): T {
+  return new Class({
+    type: "string",
+    format: "duration",
+    check: "string_format",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Number
+export type $YatspNumberParams = TypeParams<schemas.$YatspNumber<number>, "coerce"> & {
+  checks?: readonly checks.$YatspCheck<number>[];
+};
+export type $YatspNumberFormatParams = CheckTypeParams<schemas.$YatspNumberFormat, "format" | "coerce">;
+export type $YatspCheckNumberFormatParams = CheckParams<checks.$YatspCheckNumberFormat, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _number<T extends schemas.$YatspNumber>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspNumberParams
+): T {
+  return new Class(snapshotChecks({ type: "number" as const, checks: [], ...util.normalizeParams(params) }));
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _coercedNumber<T extends schemas.$YatspNumber>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspNumberParams
+): T {
+  return new Class(
+    snapshotChecks({ type: "number" as const, coerce: true, checks: [], ...util.normalizeParams(params) })
+  );
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _int<T extends schemas.$YatspNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _float32<T extends schemas.$YatspNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float32",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _float64<T extends schemas.$YatspNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "float64",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _int32<T extends schemas.$YatspNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "int32",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _uint32<T extends schemas.$YatspNumberFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspCheckNumberFormatParams
+): T {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "uint32",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Boolean
+export type $YatspBooleanParams = TypeParams<schemas.$YatspBoolean<boolean>, "coerce">;
+// @__NO_SIDE_EFFECTS__
+export function _boolean<T extends schemas.$YatspBoolean>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBooleanParams
+): T {
+  return new Class({
+    type: "boolean",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedBoolean<T extends schemas.$YatspBoolean>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBooleanParams
+): T {
+  return new Class({
+    type: "boolean",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+// BigInt
+export type $YatspBigIntParams = TypeParams<schemas.$YatspBigInt<bigint>>;
+export type $YatspBigIntFormatParams = CheckTypeParams<schemas.$YatspBigIntFormat, "format" | "coerce">;
+export type $YatspCheckBigIntFormatParams = CheckParams<checks.$YatspCheckBigIntFormat, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _bigint<T extends schemas.$YatspBigInt>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBigIntParams
+): T {
+  return new Class({
+    type: "bigint",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedBigint<T extends schemas.$YatspBigInt>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBigIntParams
+): T {
+  return new Class({
+    type: "bigint",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _int64<T extends schemas.$YatspBigIntFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBigIntFormatParams
+): T {
+  return new Class({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "int64",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _uint64<T extends schemas.$YatspBigIntFormat>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspBigIntFormatParams
+): T {
+  return new Class({
+    type: "bigint",
+    check: "bigint_format",
+    abort: false,
+    format: "uint64",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Symbol
+export type $YatspSymbolParams = TypeParams<schemas.$YatspSymbol>;
+// @__NO_SIDE_EFFECTS__
+export function _symbol<T extends schemas.$YatspSymbol>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspSymbolParams
+): T {
+  return new Class({
+    type: "symbol",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Undefined
+export type $YatspUndefinedParams = TypeParams<schemas.$YatspUndefined>;
+// @__NO_SIDE_EFFECTS__
+export function _undefined<T extends schemas.$YatspUndefined>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspUndefinedParams
+): T {
+  return new Class({
+    type: "undefined",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Null
+export type $YatspNullParams = TypeParams<schemas.$YatspNull>;
+// @__NO_SIDE_EFFECTS__
+export function _null<T extends schemas.$YatspNull>(Class: util.SchemaClass<T>, params?: string | $YatspNullParams): T {
+  return new Class({
+    type: "null",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Any
+export type $YatspAnyParams = TypeParams<schemas.$YatspAny>;
+// @__NO_SIDE_EFFECTS__
+export function _any<T extends schemas.$YatspAny>(Class: util.SchemaClass<T>): T {
+  return new Class({
+    type: "any",
+  });
+}
+
+// Unknown
+export type $YatspUnknownParams = TypeParams<schemas.$YatspUnknown>;
+// @__NO_SIDE_EFFECTS__
+export function _unknown<T extends schemas.$YatspUnknown>(Class: util.SchemaClass<T>): T {
+  return new Class({
+    type: "unknown",
+  });
+}
+
+// Never
+export type $YatspNeverParams = TypeParams<schemas.$YatspNever>;
+// @__NO_SIDE_EFFECTS__
+export function _never<T extends schemas.$YatspNever>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspNeverParams
+): T {
+  return new Class({
+    type: "never",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Void
+export type $YatspVoidParams = TypeParams<schemas.$YatspVoid>;
+// @__NO_SIDE_EFFECTS__
+export function _void<T extends schemas.$YatspVoid>(Class: util.SchemaClass<T>, params?: string | $YatspVoidParams): T {
+  return new Class({
+    type: "void",
+    ...util.normalizeParams(params),
+  });
+}
+
+// Date
+export type $YatspDateParams = TypeParams<schemas.$YatspDate, "coerce">;
+// @__NO_SIDE_EFFECTS__
+export function _date<T extends schemas.$YatspDate>(Class: util.SchemaClass<T>, params?: string | $YatspDateParams): T {
+  return new Class({
+    type: "date",
+    ...util.normalizeParams(params),
+  });
+}
+// @__NO_SIDE_EFFECTS__
+export function _coercedDate<T extends schemas.$YatspDate>(
+  Class: util.SchemaClass<T>,
+  params?: string | $YatspDateParams
+): T {
+  return new Class({
+    type: "date",
+    coerce: true,
+    ...util.normalizeParams(params),
+  });
+}
+
+// NaN
+export type $YatspNaNParams = TypeParams<schemas.$YatspNaN>;
+// @__NO_SIDE_EFFECTS__
+export function _nan<T extends schemas.$YatspNaN>(Class: util.SchemaClass<T>, params?: string | $YatspNaNParams): T {
+  return new Class({
+    type: "nan",
+    ...util.normalizeParams(params),
+  });
+}
+
+// export type $YatspCheckParams = CheckParams<checks.$YatspCheck, "abort" | "when">;
+
+export type $YatspCheckLessThanParams = CheckParams<checks.$YatspCheckLessThan, "inclusive" | "value" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _lt(
+  value: util.Numeric,
+  params?: string | $YatspCheckLessThanParams
+): checks.$YatspCheckLessThan<util.Numeric> {
+  return new checks.$YatspCheckLessThan({
+    check: "less_than",
+    ...util.normalizeParams(params),
+    value,
+    inclusive: false,
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _lte(
+  value: util.Numeric,
+  params?: string | $YatspCheckLessThanParams
+): checks.$YatspCheckLessThan<util.Numeric> {
+  return new checks.$YatspCheckLessThan({
+    check: "less_than",
+
+    ...util.normalizeParams(params),
+    value,
+    inclusive: true,
+  });
+}
+export {
+  /** @deprecated Use `z.lte()` instead. */
+  _lte as _max,
+};
+
+// YatspCheckGreaterThan
+export type $YatspCheckGreaterThanParams = CheckParams<checks.$YatspCheckGreaterThan, "inclusive" | "value" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _gt(
+  value: util.Numeric,
+  params?: string | $YatspCheckGreaterThanParams
+): checks.$YatspCheckGreaterThan {
+  return new checks.$YatspCheckGreaterThan({
+    check: "greater_than",
+
+    ...util.normalizeParams(params),
+    value,
+    inclusive: false,
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _gte(
+  value: util.Numeric,
+  params?: string | $YatspCheckGreaterThanParams
+): checks.$YatspCheckGreaterThan {
+  return new checks.$YatspCheckGreaterThan({
+    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?: string | $YatspCheckGreaterThanParams): checks.$YatspCheckGreaterThan {
+  return _gt(0, params);
+}
+
+// negative
+// @__NO_SIDE_EFFECTS__
+export function _negative(params?: string | $YatspCheckLessThanParams): checks.$YatspCheckLessThan {
+  return _lt(0, params);
+}
+
+// nonpositive
+// @__NO_SIDE_EFFECTS__
+export function _nonpositive(params?: string | $YatspCheckLessThanParams): checks.$YatspCheckLessThan {
+  return _lte(0, params);
+}
+
+// nonnegative
+// @__NO_SIDE_EFFECTS__
+export function _nonnegative(params?: string | $YatspCheckGreaterThanParams): checks.$YatspCheckGreaterThan {
+  return _gte(0, params);
+}
+
+export type $YatspCheckMultipleOfParams = CheckParams<checks.$YatspCheckMultipleOf, "value" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _multipleOf(
+  value: number | bigint,
+  params?: string | $YatspCheckMultipleOfParams
+): checks.$YatspCheckMultipleOf {
+  return new checks.$YatspCheckMultipleOf({
+    check: "multiple_of",
+    ...util.normalizeParams(params),
+    value,
+  });
+}
+
+export type $YatspCheckMaxSizeParams = CheckParams<checks.$YatspCheckMaxSize, "maximum" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _maxSize(
+  maximum: number,
+  params?: string | $YatspCheckMaxSizeParams
+): checks.$YatspCheckMaxSize<util.HasSize> {
+  return new checks.$YatspCheckMaxSize({
+    check: "max_size",
+    ...util.normalizeParams(params),
+    maximum,
+  });
+}
+
+export type $YatspCheckMinSizeParams = CheckParams<checks.$YatspCheckMinSize, "minimum" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _minSize(
+  minimum: number,
+  params?: string | $YatspCheckMinSizeParams
+): checks.$YatspCheckMinSize<util.HasSize> {
+  return new checks.$YatspCheckMinSize({
+    check: "min_size",
+    ...util.normalizeParams(params),
+    minimum,
+  });
+}
+
+export type $YatspCheckSizeEqualsParams = CheckParams<checks.$YatspCheckSizeEquals, "size" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _size(
+  size: number,
+  params?: string | $YatspCheckSizeEqualsParams
+): checks.$YatspCheckSizeEquals<util.HasSize> {
+  return new checks.$YatspCheckSizeEquals({
+    check: "size_equals",
+    ...util.normalizeParams(params),
+    size,
+  });
+}
+
+export type $YatspCheckMaxLengthParams = CheckParams<checks.$YatspCheckMaxLength, "maximum" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _maxLength(
+  maximum: number,
+  params?: string | $YatspCheckMaxLengthParams
+): checks.$YatspCheckMaxLength<util.HasLength> {
+  const ch = new checks.$YatspCheckMaxLength({
+    check: "max_length",
+    ...util.normalizeParams(params),
+    maximum,
+  });
+  return ch;
+}
+
+export type $YatspCheckMinLengthParams = CheckParams<checks.$YatspCheckMinLength, "minimum" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _minLength(
+  minimum: number,
+  params?: string | $YatspCheckMinLengthParams
+): checks.$YatspCheckMinLength<util.HasLength> {
+  return new checks.$YatspCheckMinLength({
+    check: "min_length",
+    ...util.normalizeParams(params),
+    minimum,
+  });
+}
+
+export type $YatspCheckLengthEqualsParams = CheckParams<checks.$YatspCheckLengthEquals, "length" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _length(
+  length: number,
+  params?: string | $YatspCheckLengthEqualsParams
+): checks.$YatspCheckLengthEquals<util.HasLength> {
+  return new checks.$YatspCheckLengthEquals({
+    check: "length_equals",
+    ...util.normalizeParams(params),
+    length,
+  });
+}
+
+export type $YatspCheckRegexParams = CheckParams<checks.$YatspCheckRegex, "format" | "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _regex(pattern: RegExp, params?: string | $YatspCheckRegexParams): checks.$YatspCheckRegex {
+  return new checks.$YatspCheckRegex({
+    check: "string_format",
+    format: "regex",
+    ...util.normalizeParams(params),
+    pattern,
+  });
+}
+
+export type $YatspCheckLowerCaseParams = CheckParams<checks.$YatspCheckLowerCase, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _lowercase(params?: string | $YatspCheckLowerCaseParams): checks.$YatspCheckLowerCase {
+  return new checks.$YatspCheckLowerCase({
+    check: "string_format",
+    format: "lowercase",
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $YatspCheckUpperCaseParams = CheckParams<checks.$YatspCheckUpperCase, "format" | "when">;
+
+// @__NO_SIDE_EFFECTS__
+export function _uppercase(params?: string | $YatspCheckUpperCaseParams): checks.$YatspCheckUpperCase {
+  return new checks.$YatspCheckUpperCase({
+    check: "string_format",
+    format: "uppercase",
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $YatspCheckIncludesParams = CheckParams<
+  checks.$YatspCheckIncludes,
+  "includes" | "format" | "when" | "pattern"
+>;
+// @__NO_SIDE_EFFECTS__
+export function _includes(includes: string, params?: string | $YatspCheckIncludesParams): checks.$YatspCheckIncludes {
+  return new checks.$YatspCheckIncludes({
+    check: "string_format",
+    format: "includes",
+    ...util.normalizeParams(params),
+    includes,
+  });
+}
+export type $YatspCheckStartsWithParams = CheckParams<
+  checks.$YatspCheckStartsWith,
+  "prefix" | "format" | "when" | "pattern"
+>;
+// @__NO_SIDE_EFFECTS__
+export function _startsWith(
+  prefix: string,
+  params?: string | $YatspCheckStartsWithParams
+): checks.$YatspCheckStartsWith {
+  return new checks.$YatspCheckStartsWith({
+    check: "string_format",
+    format: "starts_with",
+    ...util.normalizeParams(params),
+    prefix,
+  });
+}
+
+export type $YatspCheckEndsWithParams = CheckParams<
+  checks.$YatspCheckEndsWith,
+  "suffix" | "format" | "pattern" | "when"
+>;
+
+// @__NO_SIDE_EFFECTS__
+export function _endsWith(suffix: string, params?: string | $YatspCheckEndsWithParams): checks.$YatspCheckEndsWith {
+  return new checks.$YatspCheckEndsWith({
+    check: "string_format",
+    format: "ends_with",
+    ...util.normalizeParams(params),
+    suffix,
+  });
+}
+
+export type $YatspCheckPropertyParams = CheckParams<checks.$YatspCheckProperty, "property" | "schema" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _property<K extends string, T extends schemas.$YatspType>(
+  property: K,
+  schema: T,
+  params?: string | $YatspCheckPropertyParams
+): checks.$YatspCheckProperty<{ [k in K]: util.Widen<core.input<T>> }> {
+  return new checks.$YatspCheckProperty({
+    check: "property",
+    property,
+    schema,
+    ...util.normalizeParams(params),
+  });
+}
+
+export type $YatspCheckPropertiesParams = CheckParams<checks.$YatspCheckProperties, "shape" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _properties<Shape extends schemas.$YatspShape>(
+  shape: Shape,
+  params?: string | $YatspCheckPropertiesParams
+): checks.$YatspCheckProperties<Shape> {
+  return new checks.$YatspCheckProperties({
+    check: "properties",
+    shape,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+export type $YatspCheckMimeTypeParams = CheckParams<checks.$YatspCheckMimeType, "mime" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _mime(
+  types: util.MimeTypes[],
+  params?: string | $YatspCheckMimeTypeParams
+): checks.$YatspCheckMimeType {
+  return new checks.$YatspCheckMimeType({
+    check: "mime_type",
+    mime: types,
+    ...util.normalizeParams(params),
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _overwrite<T>(tx: (input: T) => T): checks.$YatspCheckOverwrite<T> {
+  return new checks.$YatspCheckOverwrite({
+    check: "overwrite",
+    tx,
+  }) as checks.$YatspCheckOverwrite<T>;
+}
+// normalize
+// @__NO_SIDE_EFFECTS__
+export function _normalize(
+  form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})
+): checks.$YatspCheckOverwrite<string> {
+  return _overwrite((input) => input.normalize(form));
+}
+
+// trim
+// @__NO_SIDE_EFFECTS__
+export function _trim(): checks.$YatspCheckOverwrite<string> {
+  return _overwrite((input) => input.trim());
+}
+// toLowerCase
+// @__NO_SIDE_EFFECTS__
+export function _toLowerCase(): checks.$YatspCheckOverwrite<string> {
+  return _overwrite((input) => input.toLowerCase());
+}
+// toUpperCase
+// @__NO_SIDE_EFFECTS__
+export function _toUpperCase(): checks.$YatspCheckOverwrite<string> {
+  return _overwrite((input) => input.toUpperCase());
+}
+// slugify
+// @__NO_SIDE_EFFECTS__
+export function _slugify(): checks.$YatspCheckOverwrite<string> {
+  return _overwrite((input) => util.slugify(input));
+}
+
+///////  collections   ///////
+
+// Array
+export type $YatspArrayParams = TypeParams<schemas.$YatspArray, "element">;
+// @__NO_SIDE_EFFECTS__
+export function _array<T extends schemas.$YatspType>(
+  Class: util.SchemaClass<schemas.$YatspArray>,
+  element: T,
+  params?: string | $YatspArrayParams
+): schemas.$YatspArray<T> {
+  return new Class({
+    type: "array",
+    element,
+    // get element() {
+    //   return element;
+    // },
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+export type $YatspObjectParams = TypeParams<schemas.$YatspObject, "shape" | "catchall">;
+
+// YatspUnion
+export type $YatspUnionParams = TypeParams<schemas.$YatspUnion, "options">;
+// @__NO_SIDE_EFFECTS__
+export function _union<const T extends readonly schemas.$YatspObject[]>(
+  Class: util.SchemaClass<schemas.$YatspUnion>,
+  options: T,
+  params?: string | $YatspUnionParams
+): schemas.$YatspUnion<T> {
+  return new Class({
+    type: "union",
+    options,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspXor
+export type $YatspXorParams = TypeParams<schemas.$YatspXor, "options">;
+export function _xor<const T extends readonly schemas.$YatspObject[]>(
+  Class: util.SchemaClass<schemas.$YatspXor>,
+  options: T,
+  params?: string | $YatspXorParams
+): schemas.$YatspXor<T> {
+  return new Class({
+    type: "union",
+    options,
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspDiscriminatedUnion
+
+// The bound stops at `propValues`; it deliberately does not check that the option carries the discriminator. Any such check has to name the option's `input`, and constraining `input` in argument position forces TypeScript to resolve it while checking the call — circular for an option whose input references the union, which collapses the whole union to `any`. `$YatspDiscriminatedUnion` validates the discriminator lazily instead, when it builds its lookup map.
+//
+// Validating eagerly through `propValues` is not available: reading it runs the option's shape getters, and for a recursive option that getter references the union whose initializer is still running, so it throws `ReferenceError: Cannot access '...' before initialization`.
+//
+// `Object.keys` on the shape is recursion-safe by contrast — it lists the keys without invoking them — so an eager check is reachable. It was tried and reverted: a key list derived from the shape cannot be kept in agreement with `shape` itself, which resolves lazily over the object the caller passed and then freezes to a copy, and it charged every object schema construction time and memory for a check only this one type reads.
+//
+// `_Disc` is unused and retained only so `$YatspTypeDiscriminable<"kind">` keeps compiling for external callers.
+export interface $YatspTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$YatspTypeInternals {
+  propValues: util.PropValues;
+}
+
+export interface $YatspTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
+  _yatsp: $YatspTypeDiscriminableInternals;
+}
+
+export type $YatspDiscriminatedUnionParams = TypeParams<schemas.$YatspDiscriminatedUnion, "options" | "discriminator">;
+// @__NO_SIDE_EFFECTS__
+export function _discriminatedUnion<
+  Types extends [$YatspTypeDiscriminable, ...$YatspTypeDiscriminable[]],
+  Disc extends string,
+>(
+  Class: util.SchemaClass<schemas.$YatspDiscriminatedUnion>,
+  discriminator: Disc,
+  options: Types,
+  params?: string | $YatspDiscriminatedUnionParams
+): schemas.$YatspDiscriminatedUnion<Types, Disc> {
+  return new Class({
+    type: "union",
+    options: options as any as schemas.$YatspType[],
+    discriminator,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspIntersection
+export type $YatspIntersectionParams = TypeParams<schemas.$YatspIntersection, "left" | "right">;
+// @__NO_SIDE_EFFECTS__
+export function _intersection<T extends schemas.$YatspObject, U extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspIntersection>,
+  left: T,
+  right: U
+): schemas.$YatspIntersection<T, U> {
+  return new Class({
+    type: "intersection",
+    left,
+    right,
+  }) as any;
+}
+
+// YatspTuple
+export type $YatspTupleParams = TypeParams<schemas.$YatspTuple, "items" | "rest">;
+// @__NO_SIDE_EFFECTS__
+export function _tuple<T extends readonly [schemas.$YatspType, ...schemas.$YatspType[]]>(
+  Class: util.SchemaClass<schemas.$YatspTuple>,
+  items: T,
+  params?: string | $YatspTupleParams
+): schemas.$YatspTuple<T, null>;
+// @__NO_SIDE_EFFECTS__
+export function _tuple<
+  T extends readonly [schemas.$YatspType, ...schemas.$YatspType[]],
+  Rest extends schemas.$YatspType,
+>(
+  Class: util.SchemaClass<schemas.$YatspTuple>,
+  items: T,
+  rest: Rest,
+  params?: string | $YatspTupleParams
+): schemas.$YatspTuple<T, Rest>;
+// export function _tuple(
+//   Class: util.SchemaClass<schemas.$YatspTuple>,
+//   items: [],
+//   params?: string | $YatspTupleParams
+// ): schemas.$YatspTuple<[], null>;
+// @__NO_SIDE_EFFECTS__
+export function _tuple(
+  Class: util.SchemaClass<schemas.$YatspTuple>,
+  items: schemas.$YatspType[],
+  _paramsOrRest?: string | $YatspTupleParams | schemas.$YatspType,
+  _params?: string | $YatspTupleParams
+) {
+  const hasRest = _paramsOrRest instanceof schemas.$YatspType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new Class({
+    type: "tuple",
+    items,
+    rest,
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspRecord
+export type $YatspRecordParams = TypeParams<schemas.$YatspRecord, "keyType" | "valueType" | "partial">;
+// @__NO_SIDE_EFFECTS__
+export function _record<Key extends schemas.$YatspRecordKey, Value extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspRecord>,
+  keyType: Key,
+  valueType: Value,
+  params?: string | $YatspRecordParams
+): schemas.$YatspRecord<Key, Value> {
+  return new Class({
+    type: "record",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMap
+export type $YatspMapParams = TypeParams<schemas.$YatspMap, "keyType" | "valueType">;
+// @__NO_SIDE_EFFECTS__
+export function _map<Key extends schemas.$YatspObject, Value extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspMap>,
+  keyType: Key,
+  valueType: Value,
+  params?: string | $YatspMapParams
+): schemas.$YatspMap<Key, Value> {
+  return new Class({
+    type: "map",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspSet
+export type $YatspSetParams = TypeParams<schemas.$YatspSet, "valueType">;
+// @__NO_SIDE_EFFECTS__
+export function _set<Value extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspSet>,
+  valueType: Value,
+  params?: string | $YatspSetParams
+): schemas.$YatspSet<Value> {
+  return new Class({
+    type: "set",
+    valueType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspEnum
+export type $YatspEnumParams = TypeParams<schemas.$YatspEnum, "entries">;
+// @__NO_SIDE_EFFECTS__
+export function _enum<const T extends string[]>(
+  Class: util.SchemaClass<schemas.$YatspEnum>,
+  values: T,
+  params?: string | $YatspEnumParams
+): schemas.$YatspEnum<util.ToEnum<T[number]>>;
+// @__NO_SIDE_EFFECTS__
+export function _enum<T extends util.EnumLike>(
+  Class: util.SchemaClass<schemas.$YatspEnum>,
+  entries: T,
+  params?: string | $YatspEnumParams
+): schemas.$YatspEnum<T>;
+// @__NO_SIDE_EFFECTS__
+export function _enum(Class: util.SchemaClass<schemas.$YatspEnum>, values: any, params?: string | $YatspEnumParams) {
+  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;
+}
+
+// @__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<T extends util.EnumLike>(
+  Class: util.SchemaClass<schemas.$YatspEnum>,
+  entries: T,
+  params?: string | $YatspEnumParams
+): schemas.$YatspEnum<T> {
+  return new Class({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspLiteral
+export type $YatspLiteralParams = TypeParams<schemas.$YatspLiteral, "values">;
+export function _literal<const T extends Array<util.Literal>>(
+  Class: util.SchemaClass<schemas.$YatspLiteral>,
+  value: T,
+  params?: string | $YatspLiteralParams
+): schemas.$YatspLiteral<T[number]>;
+export function _literal<const T extends util.Literal>(
+  Class: util.SchemaClass<schemas.$YatspLiteral>,
+  value: T,
+  params?: string | $YatspLiteralParams
+): schemas.$YatspLiteral<T>;
+// @__NO_SIDE_EFFECTS__
+export function _literal(Class: util.SchemaClass<schemas.$YatspLiteral>, value: any, params: any) {
+  return new Class({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspFile
+export type $YatspFileParams = TypeParams<schemas.$YatspFile>;
+// @__NO_SIDE_EFFECTS__
+export function _file(
+  Class: util.SchemaClass<schemas.$YatspFile>,
+  params?: string | $YatspFileParams
+): schemas.$YatspFile {
+  return new Class({
+    type: "file",
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspTransform
+export type $YatspTransformParams = TypeParams<schemas.$YatspTransform, "transform">;
+// @__NO_SIDE_EFFECTS__
+export function _transform<I = unknown, O = I>(
+  Class: util.SchemaClass<schemas.$YatspTransform>,
+  fn: (input: I, ctx?: schemas.ParsePayload) => O
+): schemas.$YatspTransform<Awaited<O>, I> {
+  return new Class({
+    type: "transform",
+    transform: fn as any,
+  }) as any;
+}
+
+// YatspOptional
+export type $YatspOptionalParams = TypeParams<schemas.$YatspOptional, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _optional<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspOptional>,
+  innerType: T
+): schemas.$YatspOptional<T> {
+  return new Class({
+    type: "optional",
+    innerType,
+  }) as any;
+}
+
+// YatspNullable
+export type $YatspNullableParams = TypeParams<schemas.$YatspNullable, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _nullable<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspNullable>,
+  innerType: T
+): schemas.$YatspNullable<T> {
+  return new Class({
+    type: "nullable",
+    innerType,
+  }) as any;
+}
+
+// YatspDefault
+export type $YatspDefaultParams = TypeParams<schemas.$YatspDefault, "innerType" | "defaultValue">;
+// @__NO_SIDE_EFFECTS__
+export function _default<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspDefault>,
+  innerType: T,
+  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)
+): schemas.$YatspDefault<T> {
+  return new Class({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
+    },
+  }) as any;
+}
+
+// YatspNonOptional
+export type $YatspNonOptionalParams = TypeParams<schemas.$YatspNonOptional, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _nonoptional<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspNonOptional>,
+  innerType: T,
+  params?: string | $YatspNonOptionalParams
+): schemas.$YatspNonOptional<T> {
+  return new Class({
+    type: "nonoptional",
+    innerType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspSuccess
+export type $YatspSuccessParams = TypeParams<schemas.$YatspSuccess, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _success<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspSuccess>,
+  innerType: T
+): schemas.$YatspSuccess<T> {
+  return new Class({
+    type: "success",
+    innerType,
+  }) as any;
+}
+
+// YatspCatch
+export type $YatspCatchParams = TypeParams<schemas.$YatspCatch, "innerType" | "catchValue">;
+// @__NO_SIDE_EFFECTS__
+export function _catch<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspCatch>,
+  innerType: T,
+  catchValue: core.output<T> | ((ctx: schemas.$YatspCatchCtx) => core.output<T>)
+): schemas.$YatspCatch<T> {
+  return new Class({
+    type: "catch",
+    innerType,
+    catchValue: (typeof catchValue === "function" ? catchValue : util.constantCatch(catchValue)) as any,
+  }) as any;
+}
+
+// YatspPipe
+export type $YatspPipeParams = TypeParams<schemas.$YatspPipe, "in" | "out">;
+// @__NO_SIDE_EFFECTS__
+export function _pipe<
+  const A extends schemas.$YatspType,
+  B extends schemas.$YatspType<unknown, core.output<A>> = schemas.$YatspType<unknown, core.output<A>>,
+>(
+  Class: util.SchemaClass<schemas.$YatspPipe>,
+  in_: A,
+  out: B | schemas.$YatspType<unknown, core.output<A>>
+): schemas.$YatspPipe<A, B> {
+  return new Class({
+    type: "pipe",
+    in: in_,
+    out,
+  }) as any;
+}
+
+// YatspReadonly
+export type $YatspReadonlyParams = TypeParams<schemas.$YatspReadonly, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _readonly<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspReadonly>,
+  innerType: T
+): schemas.$YatspReadonly<T> {
+  return new Class({
+    type: "readonly",
+    innerType,
+  }) as any;
+}
+
+// YatspTemplateLiteral
+export type $YatspTemplateLiteralParams = TypeParams<schemas.$YatspTemplateLiteral, "parts">;
+// @__NO_SIDE_EFFECTS__
+export function _templateLiteral<const Parts extends schemas.$YatspTemplateLiteralPart[]>(
+  Class: util.SchemaClass<schemas.$YatspTemplateLiteral>,
+  parts: Parts,
+  params?: string | $YatspTemplateLiteralParams
+): schemas.$YatspTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>> {
+  return new Class({
+    type: "template_literal",
+    parts,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspLazy
+export type $YatspLazyParams = TypeParams<schemas.$YatspLazy, "getter">;
+// @__NO_SIDE_EFFECTS__
+export function _lazy<T extends schemas.$YatspType>(
+  Class: util.SchemaClass<schemas.$YatspLazy>,
+  getter: () => T
+): schemas.$YatspLazy<T> {
+  return new Class({
+    type: "lazy",
+    getter,
+  }) as any;
+}
+
+// YatspPromise
+export type $YatspPromiseParams = TypeParams<schemas.$YatspPromise, "innerType">;
+// @__NO_SIDE_EFFECTS__
+export function _promise<T extends schemas.$YatspObject>(
+  Class: util.SchemaClass<schemas.$YatspPromise>,
+  innerType: T
+): schemas.$YatspPromise<T> {
+  return new Class({
+    type: "promise",
+    innerType,
+  }) as any;
+}
+
+// YatspCustom
+export type $YatspCustomParams = CheckTypeParams<schemas.$YatspCustom, "fn">;
+// @__NO_SIDE_EFFECTS__
+export function _custom<O = unknown, I = O>(
+  Class: util.SchemaClass<schemas.$YatspCustom>,
+  fn: (data: O) => unknown,
+  _params: string | $YatspCustomParams | undefined
+): schemas.$YatspCustom<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;
+}
+
+// same as _custom but defaults to abort:false
+// @__NO_SIDE_EFFECTS__
+export function _refine<O = unknown, I = O>(
+  Class: util.SchemaClass<schemas.$YatspCustom>,
+  fn: (data: O) => unknown,
+  _params: string | $YatspCustomParams | undefined
+): schemas.$YatspCustom<O, I> {
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn: fn as any,
+    ...util.normalizeParams(_params),
+  });
+
+  return schema as any;
+}
+
+export type $YatspSuperRefineIssue<T extends errors.$YatspIssueBase = errors.$YatspIssue> = T extends any
+  ? RawIssue<T>
+  : never;
+type RawIssue<T extends errors.$YatspIssueBase> = T extends any
+  ? util.Flatten<
+      util.MakePartial<T, "message" | "path"> & {
+        /** The schema or check that originated this issue. */
+        readonly inst?: schemas.$YatspType | checks.$YatspCheck;
+        /** If `true`, Yatsp will execute subsequent checks/refinements instead of immediately aborting */
+        readonly continue?: boolean | undefined;
+      } & Record<string, unknown>
+    >
+  : never;
+
+export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
+  addIssue(arg: string | $YatspSuperRefineIssue): void;
+}
+
+export interface $YatspSuperRefineParams {
+  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _superRefine<T>(
+  fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>,
+  params?: $YatspSuperRefineParams
+): checks.$YatspCheck<T> {
+  const ch = _check<T>((payload) => {
+    (payload as $RefinementCtx).addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, ch._yatsp.def));
+      } else {
+        // for Yatsp 3 backwards compatibility
+        const _issue: any = issue;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ??= "custom";
+        if (!("input" in _issue)) _issue.input = payload.value;
+        _issue.inst ??= ch;
+        _issue.continue ??= !ch._yatsp.def.abort; // abort is always undefined, so this is always true...
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+
+    return fn(payload.value, payload as $RefinementCtx<T>);
+  }, params);
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _check<O = unknown>(
+  fn: schemas.CheckFn<O>,
+  params?: string | $YatspCustomParams
+): checks.$YatspCheck<O> {
+  const ch = new checks.$YatspCheck({
+    check: "custom",
+    ...util.normalizeParams(params),
+  });
+
+  ch._yatsp.check = fn;
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function describe<T>(description: string): checks.$YatspCheck<T> {
+  const ch = new checks.$YatspCheck({ check: "describe" });
+  ch._yatsp.onattach = [
+    (inst) => {
+      const existing = registries.globalRegistry.get(inst) ?? {};
+      registries.globalRegistry.add(inst, { ...existing, description });
+    },
+  ];
+  ch._yatsp.check = () => {}; // no-op check
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function meta<T>(metadata: registries.GlobalMeta): checks.$YatspCheck<T> {
+  const ch = new checks.$YatspCheck({ check: "meta" });
+  ch._yatsp.onattach = [
+    (inst) => {
+      const existing = registries.globalRegistry.get(inst) ?? {};
+      registries.globalRegistry.add(inst, { ...existing, ...metadata });
+    },
+  ];
+  ch._yatsp.check = () => {}; // no-op check
+  return ch;
+}
+
+// export type $YatspCustomParams = CheckTypeParams<schemas.$YatspCustom, "fn">
+
+/////////    STRINGBOOL   /////////
+
+// stringbool
+export interface $YatspStringBoolParams extends TypeParams {
+  truthy?: string[];
+  falsy?: string[];
+  /**
+   * Options: `"sensitive"`, `"insensitive"`
+   *
+   * @default `"insensitive"`
+   */
+  case?: "sensitive" | "insensitive" | undefined;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _stringbool(
+  Classes: {
+    Codec?: typeof schemas.$YatspCodec;
+    Boolean?: typeof schemas.$YatspBoolean;
+    String?: typeof schemas.$YatspString;
+  },
+  _params?: string | $YatspStringBoolParams
+): schemas.$YatspCodec<schemas.$YatspString, schemas.$YatspBoolean> {
+  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 _Codec = Classes.Codec ?? schemas.$YatspCodec;
+  const _Boolean = Classes.Boolean ?? schemas.$YatspBoolean;
+  const _String = Classes.String ?? schemas.$YatspString;
+
+  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 as any,
+    out: booleanSchema as any,
+    transform: ((input: string, payload: schemas.ParsePayload<string>) => {
+      let data: string = 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 {} as never;
+      }
+    }) as any,
+    reverseTransform: ((input: boolean, _payload: schemas.ParsePayload<boolean>) => {
+      if (input === true) {
+        return truthyArray[0] || "true";
+      } else {
+        return falsyArray[0] || "false";
+      }
+    }) as any,
+    error: params.error,
+  }) as any;
+
+  codec._yatsp.bag.truthy = truthyArray;
+  codec._yatsp.bag.falsy = falsyArray;
+  codec._yatsp.bag.case = params.case ?? "insensitive";
+
+  return codec;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _stringFormat<Format extends string>(
+  Class: typeof schemas.$YatspCustomStringFormat,
+  format: Format,
+  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,
+  _params: string | $YatspStringFormatParams = {}
+): schemas.$YatspCustomStringFormat<Format> {
+  const params = util.normalizeParams(_params);
+  const def: schemas.$YatspCustomStringFormatDef = {
+    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;
+}