@willaimg/yatsp 4.3.6

package/src/v4/classic/schemas.ts

@@ -0,0 +1,2994 @@
+import type { $YatspBigIntFormats } from "../core/checks.js";
+import * as core from "../core/index.js";
+import { util, type $YatspNumberFormats } from "../core/index.js";
+import * as processors from "../core/json-schema-processors.js";
+import * as regexes from "../core/regexes.js";
+import type { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
+import { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from "../core/to-json-schema.js";
+import en from "../locales/en.js";
+
+import * as checks from "./checks.js";
+import * as parse from "./parse.js";
+
+// Register English as the default locale on first YatspType construction. Hooked into the `YatspType` `$constructor` (rather than a top-level `config(en())` in `external.ts`) so bundlers honoring `sideEffects: false` can't tree-shake it out — see #5953, #5725. An explicit `z.config(z.locales.xx())` call wins regardless of order, since this only sets the default when none is present.
+function _ensureDefaultLocale(): void {
+  if (!core.globalConfig.localeError) core.config(en());
+}
+
+// the default memoizer is read by the core container init, which runs before `YatspType.init`, so each container calls this first
+function _ensureDefaultMemoizer(): void {
+  if (!core.globalConfig.memoizer) core.config({ memoizer: core.memoizer() });
+}
+
+// Methods live on each concrete constructor's prototype and materialize per instance on first access, so a schema only pays for what it is asked for.
+
+///////////////////////////////////////////
+///////////////////////////////////////////
+////////////                   ////////////
+////////////      YatspType      ////////////
+////////////                   ////////////
+///////////////////////////////////////////
+///////////////////////////////////////////
+
+export type YatspStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
+export interface YatspType<
+  out Output = unknown,
+  out Input = unknown,
+  out Internals extends core.$YatspTypeInternals<Output, Input> = core.$YatspTypeInternals<Output, Input>,
+> extends core.$YatspType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: core.ToJSONSchemaParams): core.YatspStandardJSONSchemaPayload<this>;
+
+  // base methods
+  check(...checks: (core.CheckFn<core.output<this>> | core.$YatspCheck<core.output<this>>)[]): this;
+  with(...checks: (core.CheckFn<core.output<this>> | core.$YatspCheck<core.output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: { parent: boolean }): this;
+  register<R extends core.$YatspRegistry>(
+    registry: R,
+    ...meta: this extends R["_schema"]
+      ? undefined extends R["_meta"]
+        ? [core.$replace<R["_meta"], this>?]
+        : [core.$replace<R["_meta"], this>]
+      : ["Incompatible schema"]
+  ): this;
+
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(
+    value?: T
+  ): PropertyKey extends T ? this : core.$YatspBranded<this, T, Dir>;
+
+  // parsing
+  parse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): core.output<this>;
+  safeParse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): parse.YatspSafeParseResult<core.output<this>>;
+  parseAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<core.output<this>>;
+  safeParseAsync(
+    data: unknown,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): Promise<parse.YatspSafeParseResult<core.output<this>>>;
+  spa: (
+    data: unknown,
+    params?: core.ParseContext<core.$YatspIssue>
+  ) => Promise<parse.YatspSafeParseResult<core.output<this>>>;
+  validate(data: unknown, params?: core.ParseContext<core.$YatspIssue>): data is core.input<this>;
+  validateAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<boolean>;
+
+  // encoding/decoding
+  encode(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): core.input<this>;
+  decode(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): core.output<this>;
+  encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<core.input<this>>;
+  decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<core.output<this>>;
+  safeEncode(
+    data: core.output<this>,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): parse.YatspSafeParseResult<core.input<this>>;
+  safeDecode(
+    data: core.input<this>,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): parse.YatspSafeParseResult<core.output<this>>;
+  safeEncodeAsync(
+    data: core.output<this>,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): Promise<parse.YatspSafeParseResult<core.input<this>>>;
+  safeDecodeAsync(
+    data: core.input<this>,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): Promise<parse.YatspSafeParseResult<core.output<this>>>;
+
+  // refinements
+  refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(
+    check: Ch,
+    params?: string | core.$YatspCustomParams
+  ): Ch extends (arg: any) => arg is infer R ? this & YatspType<R, core.input<this>> : this;
+  superRefine(
+    refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>,
+    params?: core.$YatspSuperRefineParams
+  ): this;
+  overwrite(fn: (x: core.output<this>) => core.output<this>): this;
+
+  // wrappers
+  optional(): YatspOptional<this>;
+  exactOptional(): YatspExactOptional<this>;
+  nonoptional(params?: string | core.$YatspNonOptionalParams): YatspNonOptional<this>;
+  nullable(): YatspNullable<this>;
+  nullish(): YatspOptional<YatspNullable<this>>;
+  default(def: util.NoUndefined<core.output<this>>): YatspDefault<this>;
+  default(def: () => util.NoUndefined<core.output<this>>): YatspDefault<this>;
+  prefault(def: () => core.input<this>): YatspPrefault<this>;
+  prefault(def: core.input<this>): YatspPrefault<this>;
+  array(): YatspArray<this>;
+  or<T extends core.SomeType>(option: T): YatspUnion<[this, T]>;
+  and<T extends core.SomeType>(incoming: T): YatspIntersection<this, T>;
+  transform<NewOut>(
+    transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
+  ): YatspPipe<this, YatspTransform<Awaited<NewOut>, core.output<this>>>;
+  catch(def: core.output<this>): YatspCatch<this>;
+  catch(def: (ctx: core.$YatspCatchCtx) => core.output<this>): YatspCatch<this>;
+  pipe<T extends core.$YatspType<any, core.output<this>>>(
+    target: T | core.$YatspType<any, core.output<this>>
+  ): YatspPipe<this, T>;
+  readonly(): YatspReadonly<this>;
+
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): core.$replace<core.GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: core.$replace<core.GlobalMeta, this>): this;
+
+  // helpers
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+
+export interface _YatspType<out Internals extends core.$YatspTypeInternals = core.$YatspTypeInternals>
+  extends YatspType<any, any, Internals> {}
+
+export const YatspType: core.$constructor<YatspType> = /*@__PURE__*/ core.$constructor<YatspType>(
+  "YatspType",
+  (inst, def) => {
+    _ensureDefaultLocale();
+    core.$YatspType.init(inst, def);
+
+    inst.def = def;
+    inst.type = def.type;
+
+    return inst;
+  },
+  {
+    check(...chks) {
+      const def = this.def;
+      return this.clone(
+        util.mergeDefs(def, {
+          checks: [
+            ...(def.checks ?? []),
+            ...chks.map((ch) =>
+              typeof ch === "function" ? { _yatsp: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
+            ),
+          ],
+        }),
+        { parent: true }
+      );
+    },
+    with(...chks) {
+      return this.check(...chks);
+    },
+    clone(def, params) {
+      return core.clone(this, def, params);
+    },
+    brand() {
+      return this;
+    },
+    register(reg, meta) {
+      reg.add(this, meta);
+      return this;
+    },
+    refine(check, params) {
+      return this.check(refine(check, params));
+    },
+    superRefine(refinement, params) {
+      return this.check(superRefine(refinement, params));
+    },
+    overwrite(fn) {
+      return this.check(checks.overwrite(fn));
+    },
+    optional() {
+      return optional(this);
+    },
+    exactOptional() {
+      return exactOptional(this);
+    },
+    nullable() {
+      return nullable(this);
+    },
+    nullish() {
+      return optional(nullable(this));
+    },
+    nonoptional(params) {
+      return nonoptional(this, params);
+    },
+    array() {
+      return array(this);
+    },
+    or(arg) {
+      return union([this, arg]);
+    },
+    and(arg) {
+      return intersection(this, arg);
+    },
+    transform(tx) {
+      return pipe(this, transform(tx));
+    },
+    default(d) {
+      return _default(this, d);
+    },
+    prefault(d) {
+      return prefault(this, d);
+    },
+    catch(params) {
+      return _catch(this, params);
+    },
+    pipe(target) {
+      return pipe(this, target);
+    },
+    readonly() {
+      return readonly(this);
+    },
+    describe(description) {
+      const cl = this.clone();
+      core.globalRegistry.add(cl, { description });
+      return cl;
+    },
+    meta(...args: any[]): any {
+      // overloaded: meta() returns the registered metadata, meta(data) returns a clone with `data` registered. The mapped type picks up the second overload, so we accept variadic any-args and return `any` to satisfy both at runtime.
+      if (args.length === 0) return core.globalRegistry.get(this);
+      const cl = this.clone();
+      core.globalRegistry.add(cl, args[0]);
+      return cl;
+    },
+    isOptional() {
+      return this.safeParse(undefined).success;
+    },
+    isNullable() {
+      return this.safeParse(null).success;
+    },
+    apply(fn, ...args) {
+      return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
+    // Overrides core's `~standard` to add `jsonSchema`. Must stay a prototype entry: redefining it per instance demotes instances to dictionary mode.
+    get "~standard"(): YatspType["~standard"] {
+      return util.hide(this, "~standard", {
+        ...core.standardProps(this),
+        jsonSchema: {
+          input: createStandardJSONSchemaMethod(this, "input"),
+          output: createStandardJSONSchemaMethod(this, "output"),
+        },
+      } as YatspType["~standard"]);
+    },
+    set "~standard"(value: YatspType["~standard"]) {
+      util.own(this, "~standard", value);
+    },
+    parse: function _parse(data, params) {
+      return parse.parse(this, data, params, { callee: _parse });
+    },
+    parseAsync: async function _parseAsync(data, params) {
+      return await parse.parseAsync(this, data, params, { callee: _parseAsync });
+    },
+    safeParse(data, params) {
+      return parse.safeParse(this, data, params);
+    },
+    async safeParseAsync(data, params) {
+      return parse.safeParseAsync(this, data, params);
+    },
+    // `spa` is an alias: same function object as `safeParseAsync`, as before.
+    get spa(): YatspType["safeParseAsync"] {
+      return this?.safeParseAsync;
+    },
+    set spa(value: YatspType["safeParseAsync"]) {
+      util.own(this, "spa", value);
+    },
+    validate(data, params) {
+      return parse.validate(this, data, params);
+    },
+    validateAsync(data, params) {
+      return parse.validateAsync(this, data, params);
+    },
+    encode: function _encode(data, params) {
+      return parse.encode(this, data, params, { callee: _encode });
+    },
+    decode: function _decode(data, params) {
+      return parse.decode(this, data, params, { callee: _decode });
+    },
+    encodeAsync: async function _encodeAsync(data, params) {
+      return await parse.encodeAsync(this, data, params, { callee: _encodeAsync });
+    },
+    decodeAsync: async function _decodeAsync(data, params) {
+      return await parse.decodeAsync(this, data, params, { callee: _decodeAsync });
+    },
+    safeEncode(data, params) {
+      return parse.safeEncode(this, data, params);
+    },
+    safeDecode(data, params) {
+      return parse.safeDecode(this, data, params);
+    },
+    async safeEncodeAsync(data, params) {
+      return parse.safeEncodeAsync(this, data, params);
+    },
+    async safeDecodeAsync(data, params) {
+      return parse.safeDecodeAsync(this, data, params);
+    },
+    toJSONSchema(params) {
+      return createToJSONSchemaMethod(this, {})(params);
+    },
+    // Reads through to the registry on every access, so it must not cache.
+    get description(): string | undefined {
+      return core.globalRegistry.get(this as unknown as YatspType)?.description;
+    },
+    // No setter: `schema._def = x` throws, as it did when `_def` was a non-writable own property.
+    get _def(): core.$YatspTypeDef {
+      return (this as unknown as YatspType)._yatsp.def;
+    },
+  }
+);
+
+// YatspString
+export interface _YatspString<T extends core.$YatspStringInternals<unknown> = core.$YatspStringInternals<unknown>>
+  extends _YatspType<T> {
+  format: string | null;
+  minLength: number | null;
+  maxLength: number | null;
+
+  // miscellaneous checks
+  regex(regex: RegExp, params?: string | core.$YatspCheckRegexParams): this;
+  includes(value: string, params?: string | core.$YatspCheckIncludesParams): this;
+  startsWith(value: string, params?: string | core.$YatspCheckStartsWithParams): this;
+  endsWith(value: string, params?: string | core.$YatspCheckEndsWithParams): this;
+  min(minLength: number, params?: string | core.$YatspCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | core.$YatspCheckMaxLengthParams): this;
+  length(len: number, params?: string | core.$YatspCheckLengthEqualsParams): this;
+  nonempty(params?: string | core.$YatspCheckMinLengthParams): this;
+  lowercase(params?: string | core.$YatspCheckLowerCaseParams): this;
+  uppercase(params?: string | core.$YatspCheckUpperCaseParams): this;
+
+  // transforms
+  trim(): this;
+  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+  toLowerCase(): this;
+  toUpperCase(): this;
+  slugify(): this;
+}
+
+/** @internal */
+export const _YatspString: core.$constructor<_YatspString> = /*@__PURE__*/ core.$constructor<_YatspString>(
+  "_YatspString",
+  (inst, def) => {
+    core.$YatspString.init(inst, def);
+    YatspType.init(inst, def);
+
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);
+  },
+  /*@__PURE__*/ util.derived<_YatspString>(
+    {
+      format: (inst) => processors.aggregateChecks(inst).format ?? null,
+      minLength: (inst) => processors.aggregateChecks<number>(inst).minimum ?? null,
+      maxLength: (inst) => processors.aggregateChecks<number>(inst).maximum ?? null,
+    },
+    {
+      regex(...args) {
+        return this.check((checks.regex as any)(...args));
+      },
+      includes(...args) {
+        return this.check((checks.includes as any)(...args));
+      },
+      startsWith(...args) {
+        return this.check((checks.startsWith as any)(...args));
+      },
+      endsWith(...args) {
+        return this.check((checks.endsWith as any)(...args));
+      },
+      min(...args) {
+        return this.check((checks.minLength as any)(...args));
+      },
+      max(...args) {
+        return this.check((checks.maxLength as any)(...args));
+      },
+      length(...args) {
+        return this.check((checks.length as any)(...args));
+      },
+      nonempty(...args) {
+        return this.check((checks.minLength as any)(1, ...args));
+      },
+      lowercase(params) {
+        return this.check(checks.lowercase(params));
+      },
+      uppercase(params) {
+        return this.check(checks.uppercase(params));
+      },
+      trim() {
+        return this.check(checks.trim());
+      },
+      normalize(...args) {
+        return this.check(checks.normalize(...args));
+      },
+      toLowerCase() {
+        return this.check(checks.toLowerCase());
+      },
+      toUpperCase() {
+        return this.check(checks.toUpperCase());
+      },
+      slugify() {
+        return this.check(checks.slugify());
+      },
+    }
+  )
+);
+
+export interface YatspString extends _YatspString<core.$YatspStringInternals<string>> {
+  // string format checks
+
+  /** @deprecated Use `z.email()` instead. */
+  email(params?: string | core.$YatspCheckEmailParams): this;
+  /** @deprecated Use `z.url()` instead. */
+  url(params?: string | core.$YatspCheckURLParams): this;
+  /** @deprecated Use `z.jwt()` instead. */
+  jwt(params?: string | core.$YatspCheckJWTParams): this;
+  /** @deprecated Use `z.emoji()` instead. */
+  emoji(params?: string | core.$YatspCheckEmojiParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | core.$YatspCheckGUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuid(params?: string | core.$YatspCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv4(params?: string | core.$YatspCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv6(params?: string | core.$YatspCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv7(params?: string | core.$YatspCheckUUIDParams): this;
+  /** @deprecated Use `z.nanoid()` instead. */
+  nanoid(params?: string | core.$YatspCheckNanoIDParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | core.$YatspCheckGUIDParams): this;
+  /**
+   * @deprecated CUID v1 is deprecated by its authors due to information leakage
+   * (timestamps embedded in the id). Use `z.cuid2()` instead.
+   * See https://github.com/paralleldrive/cuid.
+   */
+  cuid(params?: string | core.$YatspCheckCUIDParams): this;
+  /** @deprecated Use `z.cuid2()` instead. */
+  cuid2(params?: string | core.$YatspCheckCUID2Params): this;
+  /** @deprecated Use `z.ulid()` instead. */
+  ulid(params?: string | core.$YatspCheckULIDParams): this;
+  /** @deprecated Use `z.base64()` instead. */
+  base64(params?: string | core.$YatspCheckBase64Params): this;
+  /** @deprecated Use `z.base64url()` instead. */
+  base64url(params?: string | core.$YatspCheckBase64URLParams): this;
+  // /** @deprecated Use `z.jsonString()` instead. */
+  // jsonString(params?: string | core.$YatspCheckJSONStringParams): this;
+  /** @deprecated Use `z.xid()` instead. */
+  xid(params?: string | core.$YatspCheckXIDParams): this;
+  /** @deprecated Use `z.ksuid()` instead. */
+  ksuid(params?: string | core.$YatspCheckKSUIDParams): this;
+  // /** @deprecated Use `z.ipv4()` or `z.ipv6()` instead. */
+  // ip(params?: string | (core.$YatspCheckIPv4Params & { version?: "v4" | "v6" })): YatspUnion<[this, this]>;
+  /** @deprecated Use `z.ipv4()` instead. */
+  ipv4(params?: string | core.$YatspCheckIPv4Params): this;
+  /** @deprecated Use `z.ipv6()` instead. */
+  ipv6(params?: string | core.$YatspCheckIPv6Params): this;
+  /** @deprecated Use `z.cidrv4()` instead. */
+  cidrv4(params?: string | core.$YatspCheckCIDRv4Params): this;
+  /** @deprecated Use `z.cidrv6()` instead. */
+  cidrv6(params?: string | core.$YatspCheckCIDRv6Params): this;
+  /** @deprecated Use `z.e164()` instead. */
+  e164(params?: string | core.$YatspCheckE164Params): this;
+
+  // ISO 8601 checks
+  /** @deprecated Use `z.iso.datetime()` instead. */
+  datetime(params?: string | core.$YatspCheckISODateTimeParams): this;
+  /** @deprecated Use `z.iso.date()` instead. */
+  date(params?: string | core.$YatspCheckISODateParams): this;
+  /** @deprecated Use `z.iso.time()` instead. */
+  time(
+    params?:
+      | string
+      // | {
+      //     message?: string | undefined;
+      //     precision?: number | null;
+      //   }
+      | core.$YatspCheckISOTimeParams
+  ): this;
+  /** @deprecated Use `z.iso.duration()` instead. */
+  duration(params?: string | core.$YatspCheckISODurationParams): this;
+}
+
+export const YatspString: core.$constructor<YatspString> = /*@__PURE__*/ core.$constructor<YatspString>(
+  "YatspString",
+  (inst, def) => {
+    core.$YatspString.init(inst, def);
+    _YatspString.init(inst, def);
+  },
+  {
+    email(params) {
+      return this.check(core._email(YatspEmail, params));
+    },
+    url(params) {
+      return this.check(core._url(YatspURL, params));
+    },
+    jwt(params) {
+      return this.check(core._jwt(YatspJWT, params));
+    },
+    emoji(params) {
+      return this.check(core._emoji(YatspEmoji, params));
+    },
+    guid(params) {
+      return this.check(core._guid(YatspGUID, params));
+    },
+    uuid(params) {
+      return this.check(core._uuid(YatspUUID, params));
+    },
+    uuidv4(params) {
+      return this.check(core._uuidv4(YatspUUID, params));
+    },
+    uuidv6(params) {
+      return this.check(core._uuidv6(YatspUUID, params));
+    },
+    uuidv7(params) {
+      return this.check(core._uuidv7(YatspUUID, params));
+    },
+    nanoid(params) {
+      return this.check(core._nanoid(YatspNanoID, params));
+    },
+    cuid(params) {
+      return this.check(core._cuid(YatspCUID, params));
+    },
+    cuid2(params) {
+      return this.check(core._cuid2(YatspCUID2, params));
+    },
+    ulid(params) {
+      return this.check(core._ulid(YatspULID, params));
+    },
+    base64(params) {
+      return this.check(core._base64(YatspBase64, params));
+    },
+    base64url(params) {
+      return this.check(core._base64url(YatspBase64URL, params));
+    },
+    xid(params) {
+      return this.check(core._xid(YatspXID, params));
+    },
+    ksuid(params) {
+      return this.check(core._ksuid(YatspKSUID, params));
+    },
+    ipv4(params) {
+      return this.check(core._ipv4(YatspIPv4, params));
+    },
+    ipv6(params) {
+      return this.check(core._ipv6(YatspIPv6, params));
+    },
+    cidrv4(params) {
+      return this.check(core._cidrv4(YatspCIDRv4, params));
+    },
+    cidrv6(params) {
+      return this.check(core._cidrv6(YatspCIDRv6, params));
+    },
+    e164(params) {
+      return this.check(core._e164(YatspE164, params));
+    },
+    datetime(params) {
+      return this.check(core._isoDateTime(YatspISODateTime, params as any));
+    },
+    date(params) {
+      return this.check(core._isoDate(YatspISODate, params as any));
+    },
+    time(params) {
+      return this.check(core._isoTime(YatspISOTime, params as any));
+    },
+    duration(params) {
+      return this.check(core._isoDuration(YatspISODuration, params as any));
+    },
+  }
+);
+
+export function string(params?: string | core.$YatspStringParams): YatspString;
+export function string<T extends string>(params?: string | core.$YatspStringParams): core.$YatspType<T, T>;
+export function string(params?: string | core.$YatspStringParams): YatspString {
+  return core._string(YatspString, params);
+}
+
+// YatspStringFormat
+export interface YatspStringFormat<Format extends string = string>
+  extends _YatspString<core.$YatspStringFormatInternals<Format>> {}
+export const YatspStringFormat: core.$constructor<YatspStringFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspStringFormat",
+  (inst, def) => {
+    core.$YatspStringFormat.init(inst, def);
+    _YatspString.init(inst, def);
+  }
+);
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      YatspISODateTime      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+export interface YatspISODateTime extends YatspStringFormat {
+  _yatsp: core.$YatspISODateTimeInternals;
+}
+export const YatspISODateTime: core.$constructor<YatspISODateTime> = /*@__PURE__*/ core.$constructor(
+  "YatspISODateTime",
+  (inst, def) => {
+    core.$YatspISODateTime.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      YatspISODate      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export interface YatspISODate extends YatspStringFormat {
+  _yatsp: core.$YatspISODateInternals;
+}
+export const YatspISODate: core.$constructor<YatspISODate> = /*@__PURE__*/ core.$constructor(
+  "YatspISODate",
+  (inst, def) => {
+    core.$YatspISODate.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      YatspISOTime      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export interface YatspISOTime extends YatspStringFormat {
+  _yatsp: core.$YatspISOTimeInternals;
+}
+export const YatspISOTime: core.$constructor<YatspISOTime> = /*@__PURE__*/ core.$constructor(
+  "YatspISOTime",
+  (inst, def) => {
+    core.$YatspISOTime.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      YatspISODuration      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+export interface YatspISODuration extends YatspStringFormat {
+  _yatsp: core.$YatspISODurationInternals;
+}
+export const YatspISODuration: core.$constructor<YatspISODuration> = /*@__PURE__*/ core.$constructor(
+  "YatspISODuration",
+  (inst, def) => {
+    core.$YatspISODuration.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+// YatspEmail
+export interface YatspEmail extends YatspStringFormat<"email"> {
+  _yatsp: core.$YatspEmailInternals;
+}
+export const YatspEmail: core.$constructor<YatspEmail> = /*@__PURE__*/ core.$constructor("YatspEmail", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspEmail.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function email(params?: string | core.$YatspEmailParams): YatspEmail {
+  return core._email(YatspEmail, params);
+}
+
+// YatspGUID
+export interface YatspGUID extends YatspStringFormat<"guid"> {
+  _yatsp: core.$YatspGUIDInternals;
+}
+export const YatspGUID: core.$constructor<YatspGUID> = /*@__PURE__*/ core.$constructor("YatspGUID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspGUID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function guid(params?: string | core.$YatspGUIDParams): YatspGUID {
+  return core._guid(YatspGUID, params);
+}
+
+// YatspUUID
+export interface YatspUUID extends YatspStringFormat<"uuid"> {
+  _yatsp: core.$YatspUUIDInternals;
+}
+export const YatspUUID: core.$constructor<YatspUUID> = /*@__PURE__*/ core.$constructor("YatspUUID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspUUID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function uuid(params?: string | core.$YatspUUIDParams): YatspUUID {
+  return core._uuid(YatspUUID, params);
+}
+
+export function uuidv4(params?: string | core.$YatspUUIDv4Params): YatspUUID {
+  return core._uuidv4(YatspUUID, params);
+}
+
+// YatspUUIDv6
+
+export function uuidv6(params?: string | core.$YatspUUIDv6Params): YatspUUID {
+  return core._uuidv6(YatspUUID, params);
+}
+
+// YatspUUIDv7
+
+export function uuidv7(params?: string | core.$YatspUUIDv7Params): YatspUUID {
+  return core._uuidv7(YatspUUID, params);
+}
+
+// YatspURL
+export interface YatspURL extends YatspStringFormat<"url"> {
+  _yatsp: core.$YatspURLInternals;
+}
+export const YatspURL: core.$constructor<YatspURL> = /*@__PURE__*/ core.$constructor("YatspURL", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspURL.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function url(params?: string | core.$YatspURLParams): YatspURL {
+  return core._url(YatspURL, params);
+}
+
+export function httpUrl(params?: string | Omit<core.$YatspURLParams, "protocol" | "hostname">): YatspURL {
+  return core._url(YatspURL, {
+    protocol: regexes.httpProtocol,
+    hostname: regexes.domain,
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspEmoji
+export interface YatspEmoji extends YatspStringFormat<"emoji"> {
+  _yatsp: core.$YatspEmojiInternals;
+}
+export const YatspEmoji: core.$constructor<YatspEmoji> = /*@__PURE__*/ core.$constructor("YatspEmoji", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspEmoji.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function emoji(params?: string | core.$YatspEmojiParams): YatspEmoji {
+  return core._emoji(YatspEmoji, params);
+}
+
+// YatspNanoID
+export interface YatspNanoID extends YatspStringFormat<"nanoid"> {
+  _yatsp: core.$YatspNanoIDInternals;
+}
+export const YatspNanoID: core.$constructor<YatspNanoID> = /*@__PURE__*/ core.$constructor(
+  "YatspNanoID",
+  (inst, def) => {
+    // YatspStringFormat.init(inst, def);
+    core.$YatspNanoID.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+export function nanoid(params?: string | core.$YatspNanoIDParams): YatspNanoID {
+  return core._nanoid(YatspNanoID, params);
+}
+
+// YatspCUID
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export interface YatspCUID extends YatspStringFormat<"cuid"> {
+  _yatsp: core.$YatspCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export const YatspCUID: core.$constructor<YatspCUID> = /*@__PURE__*/ core.$constructor("YatspCUID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspCUID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export function cuid(params?: string | core.$YatspCUIDParams): YatspCUID {
+  return core._cuid(YatspCUID, params);
+}
+
+// YatspCUID2
+export interface YatspCUID2 extends YatspStringFormat<"cuid2"> {
+  _yatsp: core.$YatspCUID2Internals;
+}
+export const YatspCUID2: core.$constructor<YatspCUID2> = /*@__PURE__*/ core.$constructor("YatspCUID2", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspCUID2.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function cuid2(params?: string | core.$YatspCUID2Params): YatspCUID2 {
+  return core._cuid2(YatspCUID2, params);
+}
+
+// YatspULID
+export interface YatspULID extends YatspStringFormat<"ulid"> {
+  _yatsp: core.$YatspULIDInternals;
+}
+export const YatspULID: core.$constructor<YatspULID> = /*@__PURE__*/ core.$constructor("YatspULID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspULID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function ulid(params?: string | core.$YatspULIDParams): YatspULID {
+  return core._ulid(YatspULID, params);
+}
+
+// YatspXID
+export interface YatspXID extends YatspStringFormat<"xid"> {
+  _yatsp: core.$YatspXIDInternals;
+}
+export const YatspXID: core.$constructor<YatspXID> = /*@__PURE__*/ core.$constructor("YatspXID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspXID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function xid(params?: string | core.$YatspXIDParams): YatspXID {
+  return core._xid(YatspXID, params);
+}
+
+// YatspKSUID
+export interface YatspKSUID extends YatspStringFormat<"ksuid"> {
+  _yatsp: core.$YatspKSUIDInternals;
+}
+export const YatspKSUID: core.$constructor<YatspKSUID> = /*@__PURE__*/ core.$constructor("YatspKSUID", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspKSUID.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function ksuid(params?: string | core.$YatspKSUIDParams): YatspKSUID {
+  return core._ksuid(YatspKSUID, params);
+}
+
+// YatspIP
+// export interface YatspIP extends YatspStringFormat<"ip"> {
+//   _yatsp: core.$YatspIPInternals;
+// }
+// export const YatspIP: core.$constructor<YatspIP> = /*@__PURE__*/ core.$constructor("YatspIP", (inst, def) => {
+//   // YatspStringFormat.init(inst, def);
+//   core.$YatspIP.init(inst, def);
+//   YatspStringFormat.init(inst, def);
+// });
+
+// export function ip(params?: string | core.$YatspIPParams): YatspIP {
+//   return core._ip(YatspIP, params);
+// }
+
+// YatspIPv4
+export interface YatspIPv4 extends YatspStringFormat<"ipv4"> {
+  _yatsp: core.$YatspIPv4Internals;
+}
+export const YatspIPv4: core.$constructor<YatspIPv4> = /*@__PURE__*/ core.$constructor("YatspIPv4", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspIPv4.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function ipv4(params?: string | core.$YatspIPv4Params): YatspIPv4 {
+  return core._ipv4(YatspIPv4, params);
+}
+
+// YatspMAC
+export interface YatspMAC extends YatspStringFormat<"mac"> {
+  _yatsp: core.$YatspMACInternals;
+}
+export const YatspMAC: core.$constructor<YatspMAC> = /*@__PURE__*/ core.$constructor("YatspMAC", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspMAC.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+export function mac(params?: string | core.$YatspMACParams): YatspMAC {
+  return core._mac(YatspMAC, params);
+}
+
+// YatspIPv6
+export interface YatspIPv6 extends YatspStringFormat<"ipv6"> {
+  _yatsp: core.$YatspIPv6Internals;
+}
+export const YatspIPv6: core.$constructor<YatspIPv6> = /*@__PURE__*/ core.$constructor("YatspIPv6", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspIPv6.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+export function ipv6(params?: string | core.$YatspIPv6Params): YatspIPv6 {
+  return core._ipv6(YatspIPv6, params);
+}
+
+// YatspCIDRv4
+export interface YatspCIDRv4 extends YatspStringFormat<"cidrv4"> {
+  _yatsp: core.$YatspCIDRv4Internals;
+}
+export const YatspCIDRv4: core.$constructor<YatspCIDRv4> = /*@__PURE__*/ core.$constructor(
+  "YatspCIDRv4",
+  (inst, def) => {
+    core.$YatspCIDRv4.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+export function cidrv4(params?: string | core.$YatspCIDRv4Params): YatspCIDRv4 {
+  return core._cidrv4(YatspCIDRv4, params);
+}
+
+// YatspCIDRv6
+export interface YatspCIDRv6 extends YatspStringFormat<"cidrv6"> {
+  _yatsp: core.$YatspCIDRv6Internals;
+}
+export const YatspCIDRv6: core.$constructor<YatspCIDRv6> = /*@__PURE__*/ core.$constructor(
+  "YatspCIDRv6",
+  (inst, def) => {
+    core.$YatspCIDRv6.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+export function cidrv6(params?: string | core.$YatspCIDRv6Params): YatspCIDRv6 {
+  return core._cidrv6(YatspCIDRv6, params);
+}
+
+// YatspBase64
+export interface YatspBase64 extends YatspStringFormat<"base64"> {
+  _yatsp: core.$YatspBase64Internals;
+}
+export const YatspBase64: core.$constructor<YatspBase64> = /*@__PURE__*/ core.$constructor(
+  "YatspBase64",
+  (inst, def) => {
+    // YatspStringFormat.init(inst, def);
+    core.$YatspBase64.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+export function base64(params?: string | core.$YatspBase64Params): YatspBase64 {
+  return core._base64(YatspBase64, params);
+}
+
+// YatspBase64URL
+export interface YatspBase64URL extends YatspStringFormat<"base64url"> {
+  _yatsp: core.$YatspBase64URLInternals;
+}
+export const YatspBase64URL: core.$constructor<YatspBase64URL> = /*@__PURE__*/ core.$constructor(
+  "YatspBase64URL",
+  (inst, def) => {
+    // YatspStringFormat.init(inst, def);
+    core.$YatspBase64URL.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+export function base64url(params?: string | core.$YatspBase64URLParams): YatspBase64URL {
+  return core._base64url(YatspBase64URL, params);
+}
+
+// YatspE164
+export interface YatspE164 extends YatspStringFormat<"e164"> {
+  _yatsp: core.$YatspE164Internals;
+}
+export const YatspE164: core.$constructor<YatspE164> = /*@__PURE__*/ core.$constructor("YatspE164", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspE164.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function e164(params?: string | core.$YatspE164Params): YatspE164 {
+  return core._e164(YatspE164, params);
+}
+
+// YatspCreditCard
+export interface YatspCreditCard extends YatspStringFormat<"credit_card"> {
+  _yatsp: core.$YatspCreditCardInternals;
+}
+export const YatspCreditCard: core.$constructor<YatspCreditCard> = /*@__PURE__*/ core.$constructor(
+  "YatspCreditCard",
+  (inst, def) => {
+    core.$YatspCreditCard.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+
+export function creditCard(params?: string | core.$YatspCreditCardParams): YatspCreditCard {
+  return core._creditCard(YatspCreditCard, params);
+}
+
+// YatspIBAN
+export interface YatspIBAN extends YatspStringFormat<"iban"> {
+  _yatsp: core.$YatspIBANInternals;
+}
+export const YatspIBAN: core.$constructor<YatspIBAN> = /*@__PURE__*/ core.$constructor("YatspIBAN", (inst, def) => {
+  core.$YatspIBAN.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function iban(params?: string | core.$YatspIBANParams): YatspIBAN {
+  return core._iban(YatspIBAN, params);
+}
+
+// YatspJWT
+export interface YatspJWT extends YatspStringFormat<"jwt"> {
+  _yatsp: core.$YatspJWTInternals;
+}
+export const YatspJWT: core.$constructor<YatspJWT> = /*@__PURE__*/ core.$constructor("YatspJWT", (inst, def) => {
+  // YatspStringFormat.init(inst, def);
+  core.$YatspJWT.init(inst, def);
+  YatspStringFormat.init(inst, def);
+});
+
+export function jwt(params?: string | core.$YatspJWTParams): YatspJWT {
+  return core._jwt(YatspJWT, params);
+}
+
+// YatspCustomStringFormat
+export interface YatspCustomStringFormat<Format extends string = string>
+  extends YatspStringFormat<Format>,
+    core.$YatspCustomStringFormat<Format> {
+  _yatsp: core.$YatspCustomStringFormatInternals<Format>;
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspCustomStringFormat: core.$constructor<YatspCustomStringFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspCustomStringFormat",
+  (inst, def) => {
+    // YatspStringFormat.init(inst, def);
+    core.$YatspCustomStringFormat.init(inst, def);
+    YatspStringFormat.init(inst, def);
+  }
+);
+export function stringFormat<Format extends string>(
+  format: Format,
+  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,
+  _params: string | core.$YatspStringFormatParams = {}
+): YatspCustomStringFormat<Format> {
+  return core._stringFormat(YatspCustomStringFormat, format, fnOrRegex, _params) as any;
+}
+
+export function hostname(_params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<"hostname"> {
+  return core._stringFormat(YatspCustomStringFormat, "hostname", regexes.hostname, _params) as any;
+}
+
+export function hex(_params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<"hex"> {
+  return core._stringFormat(YatspCustomStringFormat, "hex", regexes.hex, _params) as any;
+}
+
+export function currencyCode(
+  _params?: string | core.$YatspStringFormatParams
+): YatspCustomStringFormat<"currency_code"> {
+  return core._stringFormat(YatspCustomStringFormat, "currency_code", regexes.currencyCode, _params) as any;
+}
+
+export function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(
+  alg: Alg,
+  params?: {
+    enc?: Enc;
+  } & core.$YatspStringFormatParams
+): YatspCustomStringFormat<`${Alg}_${Enc}`> {
+  const enc = params?.enc ?? "hex";
+  const format = `${alg}_${enc}` as const;
+  const regex = core.regexes[format as keyof typeof core.regexes] as RegExp;
+  if (!regex) throw new Error(`Unrecognized hash format: ${format}`);
+  return core._stringFormat(YatspCustomStringFormat, format, regex, params) as any;
+}
+
+// YatspNumber
+export interface _YatspNumber<Internals extends core.$YatspNumberInternals = core.$YatspNumberInternals>
+  extends _YatspType<Internals> {
+  gt(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+  /** Identical to .min() */
+  gte(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+  min(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+  lt(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+  /** Identical to .max() */
+  lte(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+  max(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+  /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+  int(params?: string | core.$YatspCheckNumberFormatParams): this;
+  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+  safe(params?: string | core.$YatspCheckNumberFormatParams): this;
+  positive(params?: string | core.$YatspCheckGreaterThanParams): this;
+  nonnegative(params?: string | core.$YatspCheckGreaterThanParams): this;
+  negative(params?: string | core.$YatspCheckLessThanParams): this;
+  nonpositive(params?: string | core.$YatspCheckLessThanParams): this;
+  multipleOf(value: number, params?: string | core.$YatspCheckMultipleOfParams): this;
+  /** @deprecated Use `.multipleOf()` instead. */
+  step(value: number, params?: string | core.$YatspCheckMultipleOfParams): this;
+
+  /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+  finite(params?: unknown): this;
+
+  minValue: number | null;
+  maxValue: number | null;
+  /** @deprecated Check the `format` property instead.  */
+  isInt: boolean;
+  /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+  isFinite: boolean;
+  format: string | null;
+}
+
+export interface YatspNumber extends _YatspNumber<core.$YatspNumberInternals<number>> {}
+
+export const YatspNumber: core.$constructor<YatspNumber> = /*@__PURE__*/ core.$constructor<YatspNumber>(
+  "YatspNumber",
+  (inst, def) => {
+    core.$YatspNumber.init(inst, def);
+
+    YatspType.init(inst, def);
+
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);
+    inst.isFinite = true;
+  },
+  /*@__PURE__*/ util.derived<YatspNumber>(
+    {
+      minValue: (inst) => {
+        const { minimum, exclusiveMinimum } = processors.aggregateChecks<number>(inst);
+        return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);
+      },
+      maxValue: (inst) => {
+        const { maximum, exclusiveMaximum } = processors.aggregateChecks<number>(inst);
+        return Math.min(maximum ?? Number.POSITIVE_INFINITY, exclusiveMaximum ?? Number.POSITIVE_INFINITY);
+      },
+      isInt: (inst) => {
+        const { isInt, multipleOf } = processors.aggregateChecks(inst);
+        return !!isInt || !!multipleOf?.some(Number.isSafeInteger);
+      },
+      format: (inst) => processors.aggregateChecks(inst).format ?? null,
+    },
+    {
+      gt(value, params) {
+        return this.check(checks.gt(value, params));
+      },
+      gte(value, params) {
+        return this.check(checks.gte(value, params));
+      },
+      min(value, params) {
+        return this.check(checks.gte(value, params));
+      },
+      lt(value, params) {
+        return this.check(checks.lt(value, params));
+      },
+      lte(value, params) {
+        return this.check(checks.lte(value, params));
+      },
+      max(value, params) {
+        return this.check(checks.lte(value, params));
+      },
+      int(params) {
+        return this.check(int(params));
+      },
+      safe(params) {
+        return this.check(int(params));
+      },
+      positive(params) {
+        return this.check(checks.gt(0, params));
+      },
+      nonnegative(params) {
+        return this.check(checks.gte(0, params));
+      },
+      negative(params) {
+        return this.check(checks.lt(0, params));
+      },
+      nonpositive(params) {
+        return this.check(checks.lte(0, params));
+      },
+      multipleOf(value, params) {
+        return this.check(checks.multipleOf(value, params));
+      },
+      step(value, params) {
+        return this.check(checks.multipleOf(value, params));
+      },
+      finite() {
+        return this;
+      },
+    }
+  )
+);
+
+export function number(params?: string | core.$YatspNumberParams): YatspNumber {
+  return core._number(YatspNumber, params);
+}
+
+// YatspNumberFormat
+export interface YatspNumberFormat<Format extends $YatspNumberFormats = $YatspNumberFormats> extends YatspNumber {
+  _yatsp: core.$YatspNumberFormatInternals<Format>;
+}
+export const YatspNumberFormat: core.$constructor<YatspNumberFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspNumberFormat",
+  (inst, def) => {
+    core.$YatspNumberFormat.init(inst, def);
+    YatspNumber.init(inst, def);
+  }
+);
+
+// int
+export interface YatspInt extends YatspNumberFormat<"safeint"> {}
+export function int(params?: string | core.$YatspCheckNumberFormatParams): YatspInt {
+  return core._int(YatspNumberFormat, params) as YatspInt;
+}
+
+// float32
+export interface YatspFloat32 extends YatspNumberFormat<"float32"> {}
+export function float32(params?: string | core.$YatspCheckNumberFormatParams): YatspFloat32 {
+  return core._float32(YatspNumberFormat, params) as YatspFloat32;
+}
+
+// float64
+export interface YatspFloat64 extends YatspNumberFormat<"float64"> {}
+export function float64(params?: string | core.$YatspCheckNumberFormatParams): YatspFloat64 {
+  return core._float64(YatspNumberFormat, params) as YatspFloat64;
+}
+
+// int32
+export interface YatspInt32 extends YatspNumberFormat<"int32"> {}
+export function int32(params?: string | core.$YatspCheckNumberFormatParams): YatspInt32 {
+  return core._int32(YatspNumberFormat, params) as YatspInt32;
+}
+
+// uint32
+export interface YatspUInt32 extends YatspNumberFormat<"uint32"> {}
+export function uint32(params?: string | core.$YatspCheckNumberFormatParams): YatspUInt32 {
+  return core._uint32(YatspNumberFormat, params) as YatspUInt32;
+}
+
+// boolean
+export interface _YatspBoolean<T extends core.$YatspBooleanInternals = core.$YatspBooleanInternals>
+  extends _YatspType<T> {}
+export interface YatspBoolean extends _YatspBoolean<core.$YatspBooleanInternals<boolean>> {}
+export const YatspBoolean: core.$constructor<YatspBoolean> = /*@__PURE__*/ core.$constructor(
+  "YatspBoolean",
+  (inst, def) => {
+    core.$YatspBoolean.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.booleanProcessor(inst, ctx, json, params);
+  }
+);
+
+export function boolean(params?: string | core.$YatspBooleanParams): YatspBoolean {
+  return core._boolean(YatspBoolean, params);
+}
+
+// bigint
+export interface _YatspBigInt<T extends core.$YatspBigIntInternals = core.$YatspBigIntInternals> extends _YatspType<T> {
+  gte(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+  /** Alias of `.gte()` */
+  min(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+  gt(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+  /** Alias of `.lte()` */
+  lte(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+  max(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+  lt(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+  positive(params?: string | core.$YatspCheckGreaterThanParams): this;
+  negative(params?: string | core.$YatspCheckLessThanParams): this;
+  nonpositive(params?: string | core.$YatspCheckLessThanParams): this;
+  nonnegative(params?: string | core.$YatspCheckGreaterThanParams): this;
+  multipleOf(value: bigint, params?: string | core.$YatspCheckMultipleOfParams): this;
+
+  minValue: bigint | null;
+  maxValue: bigint | null;
+  format: string | null;
+}
+
+export interface YatspBigInt extends _YatspBigInt<core.$YatspBigIntInternals<bigint>> {}
+export const YatspBigInt: core.$constructor<YatspBigInt> = /*@__PURE__*/ core.$constructor<YatspBigInt>(
+  "YatspBigInt",
+  (inst, def) => {
+    core.$YatspBigInt.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);
+  },
+  /*@__PURE__*/ util.derived<YatspBigInt>(
+    {
+      minValue: (inst) => processors.aggregateChecks<bigint>(inst).minimum ?? null,
+      maxValue: (inst) => processors.aggregateChecks<bigint>(inst).maximum ?? null,
+      format: (inst) => processors.aggregateChecks(inst).format ?? null,
+    },
+    {
+      gte(value, params) {
+        return this.check(checks.gte(value, params));
+      },
+      min(value, params) {
+        return this.check(checks.gte(value, params));
+      },
+      gt(value, params) {
+        return this.check(checks.gt(value, params));
+      },
+      lt(value, params) {
+        return this.check(checks.lt(value, params));
+      },
+      lte(value, params) {
+        return this.check(checks.lte(value, params));
+      },
+      max(value, params) {
+        return this.check(checks.lte(value, params));
+      },
+      positive(params) {
+        return this.check(checks.gt(BigInt(0), params));
+      },
+      negative(params) {
+        return this.check(checks.lt(BigInt(0), params));
+      },
+      nonpositive(params) {
+        return this.check(checks.lte(BigInt(0), params));
+      },
+      nonnegative(params) {
+        return this.check(checks.gte(BigInt(0), params));
+      },
+      multipleOf(value, params) {
+        return this.check(checks.multipleOf(value, params));
+      },
+    }
+  )
+);
+
+export function bigint(params?: string | core.$YatspBigIntParams): YatspBigInt {
+  return core._bigint(YatspBigInt, params);
+}
+// bigint formats
+
+// YatspBigIntFormat
+export interface YatspBigIntFormat<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends YatspBigInt {
+  _yatsp: core.$YatspBigIntFormatInternals<Format>;
+}
+export const YatspBigIntFormat: core.$constructor<YatspBigIntFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspBigIntFormat",
+  (inst, def) => {
+    core.$YatspBigIntFormat.init(inst, def);
+    YatspBigInt.init(inst, def);
+  }
+);
+
+// int64
+export interface YatspInt64 extends YatspBigIntFormat<"int64"> {}
+export function int64(params?: string | core.$YatspBigIntFormatParams): YatspInt64 {
+  return core._int64(YatspBigIntFormat, params) as YatspInt64;
+}
+
+// uint64
+export interface YatspUInt64 extends YatspBigIntFormat<"uint64"> {}
+export function uint64(params?: string | core.$YatspBigIntFormatParams): YatspUInt64 {
+  return core._uint64(YatspBigIntFormat, params) as YatspUInt64;
+}
+
+// symbol
+export interface YatspSymbol extends _YatspType<core.$YatspSymbolInternals> {}
+export const YatspSymbol: core.$constructor<YatspSymbol> = /*@__PURE__*/ core.$constructor(
+  "YatspSymbol",
+  (inst, def) => {
+    core.$YatspSymbol.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.symbolProcessor(inst, ctx, json, params);
+  }
+);
+
+export function symbol(params?: string | core.$YatspSymbolParams): YatspSymbol {
+  return core._symbol(YatspSymbol, params);
+}
+
+// YatspUndefined
+export interface YatspUndefined extends _YatspType<core.$YatspUndefinedInternals> {}
+export const YatspUndefined: core.$constructor<YatspUndefined> = /*@__PURE__*/ core.$constructor(
+  "YatspUndefined",
+  (inst, def) => {
+    core.$YatspUndefined.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.undefinedProcessor(inst, ctx, json, params);
+  }
+);
+
+function _undefined(params?: string | core.$YatspUndefinedParams): YatspUndefined {
+  return core._undefined(YatspUndefined, params);
+}
+export { _undefined as undefined };
+
+// YatspNull
+export interface YatspNull extends _YatspType<core.$YatspNullInternals> {}
+export const YatspNull: core.$constructor<YatspNull> = /*@__PURE__*/ core.$constructor("YatspNull", (inst, def) => {
+  core.$YatspNull.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.nullProcessor(inst, ctx, json, params);
+});
+
+function _null(params?: string | core.$YatspNullParams): YatspNull {
+  return core._null(YatspNull, params);
+}
+export { _null as null };
+
+// YatspAny
+export interface YatspAny extends _YatspType<core.$YatspAnyInternals> {}
+export const YatspAny: core.$constructor<YatspAny> = /*@__PURE__*/ core.$constructor("YatspAny", (inst, def) => {
+  core.$YatspAny.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.anyProcessor(inst, ctx, json, params);
+});
+
+export function any(): YatspAny {
+  return core._any(YatspAny);
+}
+
+// YatspUnknown
+export interface YatspUnknown extends _YatspType<core.$YatspUnknownInternals> {}
+export const YatspUnknown: core.$constructor<YatspUnknown> = /*@__PURE__*/ core.$constructor(
+  "YatspUnknown",
+  (inst, def) => {
+    core.$YatspUnknown.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.unknownProcessor(inst, ctx, json, params);
+  }
+);
+
+export function unknown(): YatspUnknown {
+  return core._unknown(YatspUnknown);
+}
+
+// YatspNever
+export interface YatspNever extends _YatspType<core.$YatspNeverInternals> {}
+export const YatspNever: core.$constructor<YatspNever> = /*@__PURE__*/ core.$constructor("YatspNever", (inst, def) => {
+  core.$YatspNever.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.neverProcessor(inst, ctx, json, params);
+});
+
+export function never(params?: string | core.$YatspNeverParams): YatspNever {
+  return core._never(YatspNever, params);
+}
+
+// YatspVoid
+export interface YatspVoid extends _YatspType<core.$YatspVoidInternals> {}
+export const YatspVoid: core.$constructor<YatspVoid> = /*@__PURE__*/ core.$constructor("YatspVoid", (inst, def) => {
+  core.$YatspVoid.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.voidProcessor(inst, ctx, json, params);
+});
+
+function _void(params?: string | core.$YatspVoidParams): YatspVoid {
+  return core._void(YatspVoid, params);
+}
+export { _void as void };
+
+// YatspDate
+export interface _YatspDate<T extends core.$YatspDateInternals = core.$YatspDateInternals> extends _YatspType<T> {
+  min(value: number | Date, params?: string | core.$YatspCheckGreaterThanParams): this;
+  max(value: number | Date, params?: string | core.$YatspCheckLessThanParams): this;
+
+  /** @deprecated Not recommended. */
+  minDate: Date | null;
+  /** @deprecated Not recommended. */
+  maxDate: Date | null;
+}
+
+export interface YatspDate extends _YatspDate<core.$YatspDateInternals<Date>> {}
+export const YatspDate: core.$constructor<YatspDate> = /*@__PURE__*/ core.$constructor<YatspDate>(
+  "YatspDate",
+  (inst, def) => {
+    core.$YatspDate.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);
+
+    inst.min = (value, params) => inst.check(checks.gte(value, params));
+    inst.max = (value, params) => inst.check(checks.lte(value, params));
+  },
+  /*@__PURE__*/ util.derived<YatspDate>(
+    {
+      minDate: (inst) => {
+        const { minimum } = processors.aggregateChecks<Date>(inst);
+        return minimum ? new Date(minimum) : null;
+      },
+      maxDate: (inst) => {
+        const { maximum } = processors.aggregateChecks<Date>(inst);
+        return maximum ? new Date(maximum) : null;
+      },
+    },
+    {}
+  )
+);
+
+export function date(params?: string | core.$YatspDateParams): YatspDate {
+  return core._date(YatspDate, params);
+}
+
+// YatspArray
+export interface YatspArray<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspArrayInternals<T>>,
+    core.$YatspArray<T> {
+  element: T;
+  min(minLength: number, params?: string | core.$YatspCheckMinLengthParams): this;
+  nonempty(params?: string | core.$YatspCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | core.$YatspCheckMaxLengthParams): this;
+  length(len: number, params?: string | core.$YatspCheckLengthEqualsParams): this;
+
+  unwrap(): T;
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspArray: core.$constructor<YatspArray> = /*@__PURE__*/ core.$constructor<YatspArray>(
+  "YatspArray",
+  (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$YatspArray.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.arrayProcessor(inst, ctx, json, params);
+
+    inst.element = def.element;
+  },
+  {
+    min(n, params) {
+      return this.check(checks.minLength(n, params));
+    },
+    nonempty(params) {
+      return this.check(checks.minLength(1, params));
+    },
+    max(n, params) {
+      return this.check(checks.maxLength(n, params));
+    },
+    length(n, params) {
+      return this.check(checks.length(n, params));
+    },
+    unwrap() {
+      return this.element;
+    },
+  }
+);
+
+export function array<T extends core.SomeType>(element: T, params?: string | core.$YatspArrayParams): YatspArray<T> {
+  return core._array(YatspArray, element as any, params) as any;
+}
+
+// .keyof
+export function keyof<T extends YatspObject>(schema: T): YatspEnum<util.KeysEnum<T["_yatsp"]["output"]>> {
+  const shape = schema._yatsp.def.shape;
+  return _enum(Object.keys(shape)) as any;
+}
+
+// YatspObject
+
+export type SafeExtendShape<Base extends core.$YatspShape, Ext extends core.$YatspLooseShape> = {
+  [K in keyof Ext]: K extends keyof Base
+    ? core.output<Ext[K]> extends core.output<Base[K]>
+      ? core.input<Ext[K]> extends core.input<Base[K]>
+        ? Ext[K]
+        : never
+      : never
+    : Ext[K];
+};
+
+export interface YatspObject<
+  /** @ts-ignore Cast variance */
+  out Shape extends core.$YatspShape = core.$YatspLooseShape,
+  out Config extends core.$YatspObjectConfig = core.$strip,
+> extends _YatspType<core.$YatspObjectInternals<Shape, Config>>,
+    core.$YatspObject<Shape, Config> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  shape: Shape;
+
+  keyof(): YatspEnum<util.ToEnum<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+  catchall<T extends core.SomeType>(schema: T): YatspObject<Shape, core.$catchall<T>>;
+
+  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+  passthrough(): YatspObject<Shape, core.$loose>;
+  /** Consider `z.looseObject(A.shape)` instead */
+  loose(): YatspObject<Shape, core.$loose>;
+
+  /** Consider `z.strictObject(A.shape)` instead */
+  strict(): YatspObject<Shape, core.$strict>;
+
+  /** This is the default behavior. This method call is likely unnecessary. */
+  strip(): YatspObject<Shape, core.$strip>;
+
+  extend<U extends core.$YatspLooseShape>(shape: U): YatspObject<util.Extend<Shape, util.Writeable<U>>, Config>;
+
+  safeExtend<U extends core.$YatspLooseShape>(
+    shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>
+  ): YatspObject<util.Extend<Shape, util.Writeable<U>>, Config>;
+
+  /**
+   * @deprecated Use [`A.extend(B.shape)`](https://yatsp.dev/api?id=extend) instead.
+   */
+  merge<U extends YatspObject>(other: U): YatspObject<util.Extend<Shape, U["shape"]>, U["_yatsp"]["config"]>;
+
+  pick<M extends util.Mask<keyof Shape>>(
+    mask: M & Record<Exclude<keyof M, keyof Shape>, never>
+  ): YatspObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+
+  omit<M extends util.Mask<keyof Shape>>(
+    mask: M & Record<Exclude<keyof M, keyof Shape>, never>
+  ): YatspObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+
+  partial(): YatspObject<
+    {
+      -readonly [k in keyof Shape]: YatspOptional<Shape[k]>;
+    },
+    Config
+  >;
+  partial<M extends util.Mask<keyof Shape>>(
+    mask: M & Record<Exclude<keyof M, keyof Shape>, never>
+  ): YatspObject<
+    {
+      -readonly [k in keyof Shape]: k extends keyof M
+        ? // Shape[k] extends OptionalInSchema
+          //   ? Shape[k]
+          //   :
+          YatspOptional<Shape[k]>
+        : Shape[k];
+    },
+    Config
+  >;
+
+  // exactPartial
+  exactPartial(): YatspObject<
+    {
+      -readonly [k in keyof Shape]: YatspExactOptional<Shape[k]>;
+    },
+    Config
+  >;
+  exactPartial<M extends util.Mask<keyof Shape>>(
+    mask: M & Record<Exclude<keyof M, keyof Shape>, never>
+  ): YatspObject<
+    {
+      -readonly [k in keyof Shape]: k extends keyof M ? YatspExactOptional<Shape[k]> : Shape[k];
+    },
+    Config
+  >;
+
+  // required
+  required(): YatspObject<
+    {
+      -readonly [k in keyof Shape]: YatspNonOptional<Shape[k]>;
+    },
+    Config
+  >;
+  required<M extends util.Mask<keyof Shape>>(
+    mask: M & Record<Exclude<keyof M, keyof Shape>, never>
+  ): YatspObject<
+    {
+      -readonly [k in keyof Shape]: k extends keyof M ? YatspNonOptional<Shape[k]> : Shape[k];
+    },
+    Config
+  >;
+}
+
+export const YatspObject: core.$constructor<YatspObject> = /*@__PURE__*/ core.$constructor<YatspObject>(
+  "YatspObject",
+  (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$YatspObjectJIT.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.objectProcessor(inst, ctx, json, params);
+
+    util.installLazyProp(inst, "shape", (self) => self._yatsp.def.shape, false);
+  },
+  {
+    keyof() {
+      return _enum(Object.keys(this._yatsp.def.shape));
+    },
+    catchall(catchall) {
+      // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree
+      return this.clone(util.mergeDefs(this._yatsp.def, { catchall: catchall as any }));
+    },
+    passthrough() {
+      return this.clone(util.mergeDefs(this._yatsp.def, { catchall: unknown() }));
+    },
+    loose() {
+      return this.clone(util.mergeDefs(this._yatsp.def, { catchall: unknown() }));
+    },
+    strict() {
+      return this.clone(util.mergeDefs(this._yatsp.def, { catchall: never() }));
+    },
+    strip() {
+      return this.clone(util.mergeDefs(this._yatsp.def, { catchall: undefined }));
+    },
+    extend(incoming) {
+      return util.extend(this, incoming);
+    },
+    safeExtend(incoming) {
+      return util.safeExtend(this, incoming);
+    },
+    merge(other) {
+      return util.merge(this, other);
+    },
+    pick(mask) {
+      return util.pick(this, mask);
+    },
+    omit(mask) {
+      return util.omit(this, mask);
+    },
+    partial(...args) {
+      return util.partial(YatspOptional, this, args[0]);
+    },
+    exactPartial(...args) {
+      return util.partial(YatspExactOptional, this, args[0], "exactPartial");
+    },
+    required(...args) {
+      return util.required(YatspNonOptional, this, args[0]);
+    },
+  }
+);
+
+export function object<T extends core.$YatspLooseShape = Partial<Record<never, core.SomeType>>>(
+  shape?: T,
+  params?: string | core.$YatspObjectParams
+): YatspObject<util.Writeable<T>, core.$strip> {
+  const def: core.$YatspObjectDef = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params),
+  };
+  return new YatspObject(def) as any;
+}
+
+// strictObject
+
+export function strictObject<T extends core.$YatspLooseShape>(
+  shape: T,
+  params?: string | core.$YatspObjectParams
+): YatspObject<util.Writeable<T>, core.$strict> {
+  return new YatspObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// looseObject
+
+export function looseObject<T extends core.$YatspLooseShape>(
+  shape: T,
+  params?: string | core.$YatspObjectParams
+): YatspObject<util.Writeable<T>, core.$loose> {
+  return new YatspObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspUnion
+export interface YatspUnion<T extends readonly core.SomeType[] = readonly core.$YatspType[]>
+  extends _YatspType<core.$YatspUnionInternals<T>>,
+    core.$YatspUnion<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  options: T;
+}
+export const YatspUnion: core.$constructor<YatspUnion> = /*@__PURE__*/ core.$constructor("YatspUnion", (inst, def) => {
+  core.$YatspUnion.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);
+  inst.options = def.options;
+});
+
+export function union<const T extends readonly core.SomeType[]>(
+  options: T,
+  params?: string | core.$YatspUnionParams
+): YatspUnion<T> {
+  return new YatspUnion({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspXor
+export interface YatspXor<T extends readonly core.SomeType[] = readonly core.$YatspType[]>
+  extends _YatspType<core.$YatspXorInternals<T>>,
+    core.$YatspXor<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  options: T;
+}
+export const YatspXor: core.$constructor<YatspXor> = /*@__PURE__*/ core.$constructor("YatspXor", (inst, def) => {
+  YatspUnion.init(inst, def);
+  core.$YatspXor.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);
+  inst.options = def.options;
+});
+
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+export function xor<const T extends readonly core.SomeType[]>(
+  options: T,
+  params?: string | core.$YatspXorParams
+): YatspXor<T> {
+  return new YatspXor({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspDiscriminatedUnion
+export interface YatspDiscriminatedUnion<
+  Options extends readonly core.SomeType[] = readonly core.$YatspType[],
+  Disc extends string = string,
+> extends YatspUnion<Options>,
+    core.$YatspDiscriminatedUnion<Options, Disc> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  _yatsp: core.$YatspDiscriminatedUnionInternals<Options, Disc>;
+  def: core.$YatspDiscriminatedUnionDef<Options, Disc>;
+}
+export const YatspDiscriminatedUnion: core.$constructor<YatspDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(
+  "YatspDiscriminatedUnion",
+  (inst, def) => {
+    YatspUnion.init(inst, def);
+    core.$YatspDiscriminatedUnion.init(inst, def);
+  }
+);
+
+export function discriminatedUnion<
+  Types extends readonly [core.$YatspTypeDiscriminable, ...core.$YatspTypeDiscriminable[]],
+  Disc extends string,
+>(
+  discriminator: Disc,
+  options: Types,
+  params?: string | core.$YatspDiscriminatedUnionParams
+): YatspDiscriminatedUnion<Types, Disc> {
+  // const [options, params] = args;
+  return new YatspDiscriminatedUnion({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    discriminator,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspIntersection
+export interface YatspIntersection<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspIntersectionInternals<A, B>>,
+    core.$YatspIntersection<A, B> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspIntersection: core.$constructor<YatspIntersection> = /*@__PURE__*/ core.$constructor(
+  "YatspIntersection",
+  (inst, def) => {
+    core.$YatspIntersection.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.intersectionProcessor(inst, ctx, json, params);
+  }
+);
+
+export function intersection<T extends core.SomeType, U extends core.SomeType>(
+  left: T,
+  right: U
+): YatspIntersection<T, U> {
+  return new YatspIntersection({
+    type: "intersection",
+    left: left as any as core.$YatspType,
+    right: right as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspTuple
+export interface YatspTuple<
+  T extends util.TupleItems = readonly core.$YatspType[],
+  Rest extends core.SomeType | null = core.$YatspType | null,
+> extends _YatspType<core.$YatspTupleInternals<T, Rest>>,
+    core.$YatspTuple<T, Rest> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  rest<Rest extends core.SomeType = core.$YatspType>(rest: Rest): YatspTuple<T, Rest>;
+  partial(): YatspTuple<{ -readonly [k in keyof T]: YatspOptional<T[k]> }, Rest>;
+}
+export const YatspTuple: core.$constructor<YatspTuple> = /*@__PURE__*/ core.$constructor<YatspTuple>(
+  "YatspTuple",
+  (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$YatspTuple.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);
+  },
+  {
+    rest(rest) {
+      return this.clone({
+        ...this._yatsp.def,
+        rest: rest as any as core.$YatspType,
+      }) as any;
+    },
+    partial() {
+      const def = this._yatsp.def;
+      // a refinement was authored against the full arity; partialing would run it on a shorter array
+      if (def.checks?.length) throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+      return this.clone({
+        ...def,
+        items: def.items.map((item) => new YatspOptional({ type: "optional", innerType: item })),
+      }) as any;
+    },
+  }
+);
+
+export function tuple<T extends readonly [core.SomeType, ...core.SomeType[]]>(
+  items: T,
+  params?: string | core.$YatspTupleParams
+): YatspTuple<T, null>;
+export function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType>(
+  items: T,
+  rest: Rest,
+  params?: string | core.$YatspTupleParams
+): YatspTuple<T, Rest>;
+export function tuple(items: [], params?: string | core.$YatspTupleParams): YatspTuple<[], null>;
+export function tuple(
+  items: core.SomeType[],
+  _paramsOrRest?: string | core.$YatspTupleParams | core.SomeType,
+  _params?: string | core.$YatspTupleParams
+) {
+  const hasRest = _paramsOrRest instanceof core.$YatspType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new YatspTuple({
+    type: "tuple",
+    items: items as any as core.$YatspType[],
+    rest,
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspRecord
+export interface YatspRecord<
+  Key extends core.$YatspRecordKey = core.$YatspRecordKey,
+  Value extends core.SomeType = core.$YatspType,
+> extends _YatspType<core.$YatspRecordInternals<Key, Value>>,
+    core.$YatspRecord<Key, Value> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+}
+export const YatspRecord: core.$constructor<YatspRecord> = /*@__PURE__*/ core.$constructor(
+  "YatspRecord",
+  (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$YatspRecord.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.recordProcessor(inst, ctx, json, params);
+
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  }
+);
+
+export function record<Key extends core.$YatspRecordKey, Value extends core.SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspRecord<Key, Value> {
+  // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()
+  if (!valueType || !(valueType as any)._yatsp) {
+    return new YatspRecord({
+      type: "record",
+      keyType: string() as any,
+      valueType: keyType as any as core.$YatspType,
+      ...util.normalizeParams(valueType as string | core.$YatspRecordParams | undefined),
+    }) as any;
+  }
+  return new YatspRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+// type alksjf = core.output<core.$YatspRecordKey>;
+export function partialRecord<Key extends core.$YatspRecordKey, Value extends core.SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspRecord<Key & core.$partial, Value> {
+  return new YatspRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any,
+    ...util.normalizeParams(params),
+    partial: true,
+  }) as any;
+}
+
+export function looseRecord<Key extends core.$YatspRecordKey, Value extends core.SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspRecord<Key, Value> {
+  return new YatspRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any as core.$YatspType,
+    mode: "loose",
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMap
+export interface YatspMap<Key extends core.SomeType = core.$YatspType, Value extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspMapInternals<Key, Value>>,
+    core.$YatspMap<Key, Value> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+  min(minSize: number, params?: string | core.$YatspCheckMinSizeParams): this;
+  nonempty(params?: string | core.$YatspCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+  size(size: number, params?: string | core.$YatspCheckSizeEqualsParams): this;
+}
+export const YatspMap: core.$constructor<YatspMap> = /*@__PURE__*/ core.$constructor("YatspMap", (inst, def) => {
+  _ensureDefaultMemoizer();
+  core.$YatspMap.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);
+  inst.keyType = def.keyType;
+  inst.valueType = def.valueType;
+  inst.min = (...args) => inst.check(core._minSize(...args));
+  inst.nonempty = (params) => inst.check(core._minSize(1, params));
+  inst.max = (...args) => inst.check(core._maxSize(...args));
+  inst.size = (...args) => inst.check(core._size(...args));
+});
+
+export function map<Key extends core.SomeType, Value extends core.SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspMapParams
+): YatspMap<Key, Value> {
+  return new YatspMap({
+    type: "map",
+    keyType: keyType as any as core.$YatspType,
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspSet
+export interface YatspSet<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspSetInternals<T>>,
+    core.$YatspSet<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  min(minSize: number, params?: string | core.$YatspCheckMinSizeParams): this;
+  nonempty(params?: string | core.$YatspCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+  size(size: number, params?: string | core.$YatspCheckSizeEqualsParams): this;
+}
+export const YatspSet: core.$constructor<YatspSet> = /*@__PURE__*/ core.$constructor("YatspSet", (inst, def) => {
+  _ensureDefaultMemoizer();
+  core.$YatspSet.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.setProcessor(inst, ctx, json, params);
+
+  inst.min = (...args) => inst.check(core._minSize(...args));
+  inst.nonempty = (params) => inst.check(core._minSize(1, params));
+  inst.max = (...args) => inst.check(core._maxSize(...args));
+  inst.size = (...args) => inst.check(core._size(...args));
+});
+
+export function set<Value extends core.SomeType>(
+  valueType: Value,
+  params?: string | core.$YatspSetParams
+): YatspSet<Value> {
+  return new YatspSet({
+    type: "set",
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspEnum
+export interface YatspEnum<
+  /** @ts-ignore Cast variance */
+  out T extends util.EnumLike = util.EnumLike,
+> extends _YatspType<core.$YatspEnumInternals<T>>,
+    core.$YatspEnum<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+
+  extract<const U extends readonly (keyof T)[]>(
+    values: U,
+    params?: string | core.$YatspEnumParams
+  ): YatspEnum<util.Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(
+    values: U,
+    params?: string | core.$YatspEnumParams
+  ): YatspEnum<util.Flatten<Omit<T, U[number]>>>;
+}
+export const YatspEnum: core.$constructor<YatspEnum> = /*@__PURE__*/ core.$constructor("YatspEnum", (inst, def) => {
+  core.$YatspEnum.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);
+
+  inst.enum = def.entries;
+  // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out
+  inst.options = [...inst._yatsp.values] as util.EnumValue[];
+
+  const keys = new Set(Object.keys(def.entries));
+
+  inst.extract = (values, params) => {
+    const newEntries: Record<string, any> = {};
+    for (const value of values) {
+      if (keys.has(value)) {
+        newEntries[value] = def.entries[value];
+      } else throw new Error(`Key ${value} not found in enum`);
+    }
+    return new YatspEnum({
+      ...def,
+      checks: [],
+      ...util.normalizeParams(params),
+      entries: newEntries,
+    }) as any;
+  };
+
+  inst.exclude = (values, params) => {
+    const newEntries: Record<string, any> = { ...def.entries };
+    for (const value of values) {
+      if (keys.has(value)) {
+        delete newEntries[value];
+      } else throw new Error(`Key ${value} not found in enum`);
+    }
+    return new YatspEnum({
+      ...def,
+      checks: [],
+      ...util.normalizeParams(params),
+      entries: newEntries,
+    }) as any;
+  };
+});
+
+function _enum<const T extends readonly string[]>(
+  values: T,
+  params?: string | core.$YatspEnumParams
+): YatspEnum<util.ToEnum<T[number]>>;
+function _enum<const T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspEnum<T>;
+function _enum(values: any, params?: string | core.$YatspEnumParams) {
+  const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+
+  return new YatspEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+export { _enum as enum };
+
+/** @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>(entries: T, params?: string | core.$YatspEnumParams): YatspEnum<T> {
+  return new YatspEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as YatspEnum<T>;
+}
+
+// YatspLiteral
+export interface YatspLiteral<T extends util.Literal = util.Literal>
+  extends _YatspType<core.$YatspLiteralInternals<T>>,
+    core.$YatspLiteral<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
+}
+export const YatspLiteral: core.$constructor<YatspLiteral> = /*@__PURE__*/ core.$constructor(
+  "YatspLiteral",
+  (inst, def) => {
+    core.$YatspLiteral.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.literalProcessor(inst, ctx, json, params);
+    inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+      get() {
+        if (def.values.length > 1) {
+          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+        }
+        return def.values[0];
+      },
+    });
+  }
+);
+
+export function literal<const T extends ReadonlyArray<util.Literal>>(
+  value: T,
+  params?: string | core.$YatspLiteralParams
+): YatspLiteral<T[number]>;
+export function literal<const T extends util.Literal>(
+  value: T,
+  params?: string | core.$YatspLiteralParams
+): YatspLiteral<T>;
+export function literal(value: any, params: any) {
+  return new YatspLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspFile
+export interface YatspFile extends _YatspType<core.$YatspFileInternals>, core.$YatspFile {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  min(size: number, params?: string | core.$YatspCheckMinSizeParams): this;
+  max(size: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+  mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$YatspCheckMimeTypeParams): this;
+}
+export const YatspFile: core.$constructor<YatspFile> = /*@__PURE__*/ core.$constructor("YatspFile", (inst, def) => {
+  core.$YatspFile.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.fileProcessor(inst, ctx, json, params);
+
+  inst.min = (size, params) => inst.check(core._minSize(size, params));
+  inst.max = (size, params) => inst.check(core._maxSize(size, params));
+  inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
+});
+
+export function file(params?: string | core.$YatspFileParams): YatspFile {
+  return core._file(YatspFile, params) as any;
+}
+
+// YatspTransform
+export interface YatspTransform<O = unknown, I = unknown>
+  extends _YatspType<core.$YatspTransformInternals<O, I>>,
+    core.$YatspTransform<O, I> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspTransform: core.$constructor<YatspTransform> = /*@__PURE__*/ core.$constructor(
+  "YatspTransform",
+  (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$YatspTransform.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.transformProcessor(inst, ctx, json, params);
+
+    inst._yatsp.parse = (payload, _ctx) => {
+      if (_ctx.direction === "backward") {
+        throw new core.$YatspEncodeError(inst.constructor.name);
+      }
+
+      (payload as core.$RefinementCtx).addIssue = (issue) => {
+        if (typeof issue === "string") {
+          payload.issues.push(util.issue(issue, payload.value, def));
+        } else {
+          // for Yatsp 3 backwards compatibility
+          const _issue = issue as any;
+
+          if (_issue.fatal) _issue.continue = false;
+          _issue.code ??= "custom";
+          if (!("input" in _issue)) _issue.input = payload.value;
+          _issue.inst ??= inst;
+          // _issue.continue ??= true;
+          payload.issues.push(util.issue(_issue));
+        }
+      };
+
+      const output = def.transform(payload.value, payload);
+      if (output instanceof Promise) {
+        return output.then((output) => {
+          payload.value = output;
+          return payload;
+        });
+      }
+      payload.value = output;
+      return payload;
+    };
+  }
+);
+
+export function transform<I = unknown, O = I>(
+  fn: (input: I, ctx: core.$RefinementCtx) => O
+): YatspTransform<Awaited<O>, I> {
+  return new YatspTransform({
+    type: "transform",
+    transform: fn as any,
+  }) as any;
+}
+
+// YatspOptional
+export interface YatspOptional<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspOptionalInternals<T>>,
+    core.$YatspOptional<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspOptional: core.$constructor<YatspOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspOptional",
+  (inst, def) => {
+    core.$YatspOptional.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function optional<T extends core.SomeType>(innerType: T): YatspOptional<T> {
+  return new YatspOptional({
+    type: "optional",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspExactOptional
+export interface YatspExactOptional<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspExactOptionalInternals<T>>,
+    core.$YatspExactOptional<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspExactOptional: core.$constructor<YatspExactOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspExactOptional",
+  (inst, def) => {
+    core.$YatspExactOptional.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function exactOptional<T extends core.SomeType>(innerType: T): YatspExactOptional<T> {
+  return new YatspExactOptional({
+    type: "optional",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspNullable
+export interface YatspNullable<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspNullableInternals<T>>,
+    core.$YatspNullable<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspNullable: core.$constructor<YatspNullable> = /*@__PURE__*/ core.$constructor(
+  "YatspNullable",
+  (inst, def) => {
+    core.$YatspNullable.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.nullableProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function nullable<T extends core.SomeType>(innerType: T): YatspNullable<T> {
+  return new YatspNullable({
+    type: "nullable",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// nullish
+export function nullish<T extends core.SomeType>(innerType: T): YatspOptional<YatspNullable<T>> {
+  return optional(nullable(innerType));
+}
+
+// YatspDefault
+export interface YatspDefault<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspDefaultInternals<T>>,
+    core.$YatspDefault<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+export const YatspDefault: core.$constructor<YatspDefault> = /*@__PURE__*/ core.$constructor(
+  "YatspDefault",
+  (inst, def) => {
+    core.$YatspDefault.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.defaultProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+    inst.removeDefault = inst.unwrap;
+  }
+);
+
+export function _default<T extends core.SomeType>(
+  innerType: T,
+  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)
+): YatspDefault<T> {
+  return new YatspDefault({
+    type: "default",
+    innerType: innerType as any as core.$YatspType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
+    },
+  }) as any;
+}
+
+// YatspPrefault
+export interface YatspPrefault<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspPrefaultInternals<T>>,
+    core.$YatspPrefault<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspPrefault: core.$constructor<YatspPrefault> = /*@__PURE__*/ core.$constructor(
+  "YatspPrefault",
+  (inst, def) => {
+    core.$YatspPrefault.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.prefaultProcessor(inst, ctx, json, params);
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function prefault<T extends core.SomeType>(
+  innerType: T,
+  defaultValue: core.input<T> | (() => core.input<T>)
+): YatspPrefault<T> {
+  return new YatspPrefault({
+    type: "prefault",
+    innerType: innerType as any as core.$YatspType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
+    },
+  }) as any;
+}
+
+// YatspNonOptional
+export interface YatspNonOptional<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspNonOptionalInternals<T>>,
+    core.$YatspNonOptional<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspNonOptional: core.$constructor<YatspNonOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspNonOptional",
+  (inst, def) => {
+    core.$YatspNonOptional.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.nonoptionalProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function nonoptional<T extends core.SomeType>(
+  innerType: T,
+  params?: string | core.$YatspNonOptionalParams
+): YatspNonOptional<T> {
+  return new YatspNonOptional({
+    type: "nonoptional",
+    innerType: innerType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspSuccess
+export interface YatspSuccess<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspSuccessInternals<T>>,
+    core.$YatspSuccess<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspSuccess: core.$constructor<YatspSuccess> = /*@__PURE__*/ core.$constructor(
+  "YatspSuccess",
+  (inst, def) => {
+    core.$YatspSuccess.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.successProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function success<T extends core.SomeType>(innerType: T): YatspSuccess<T> {
+  return new YatspSuccess({
+    type: "success",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspCatch
+export interface YatspCatch<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspCatchInternals<T>>,
+    core.$YatspCatch<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+export const YatspCatch: core.$constructor<YatspCatch> = /*@__PURE__*/ core.$constructor("YatspCatch", (inst, def) => {
+  core.$YatspCatch.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.catchProcessor(inst, ctx, json, params);
+
+  inst.unwrap = () => inst._yatsp.def.innerType;
+  inst.removeCatch = inst.unwrap;
+});
+
+function _catch<T extends core.SomeType>(
+  innerType: T,
+  catchValue: core.output<T> | ((ctx: core.$YatspCatchCtx) => core.output<T>)
+): YatspCatch<T> {
+  return new YatspCatch({
+    type: "catch",
+    innerType: innerType as any as core.$YatspType,
+    catchValue: (typeof catchValue === "function" ? catchValue : core.util.constantCatch(catchValue)) as (
+      ctx: core.$YatspCatchCtx
+    ) => core.output<T>,
+  }) as any;
+}
+export { _catch as catch };
+
+// YatspNaN
+export interface YatspNaN extends _YatspType<core.$YatspNaNInternals>, core.$YatspNaN {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspNaN: core.$constructor<YatspNaN> = /*@__PURE__*/ core.$constructor("YatspNaN", (inst, def) => {
+  core.$YatspNaN.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.nanProcessor(inst, ctx, json, params);
+});
+
+export function nan(params?: string | core.$YatspNaNParams): YatspNaN {
+  return core._nan(YatspNaN, params);
+}
+
+// YatspPipe
+export interface YatspPipe<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspPipeInternals<A, B>>,
+    core.$YatspPipe<A, B> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+export const YatspPipe: core.$constructor<YatspPipe> = /*@__PURE__*/ core.$constructor("YatspPipe", (inst, def) => {
+  core.$YatspPipe.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.pipeProcessor(inst, ctx, json, params);
+
+  inst.in = def.in;
+  inst.out = def.out;
+});
+
+export function pipe<
+  const A extends core.SomeType,
+  B extends core.$YatspType<unknown, core.output<A>> = core.$YatspType<unknown, core.output<A>>,
+>(in_: A, out: B | core.$YatspType<unknown, core.output<A>>): YatspPipe<A, B>;
+export function pipe(in_: core.SomeType, out: core.SomeType) {
+  return new YatspPipe({
+    type: "pipe",
+    in: in_ as unknown as core.$YatspType,
+    out: out as unknown as core.$YatspType,
+    // ...util.normalizeParams(params),
+  });
+}
+
+// YatspCodec
+export interface YatspCodec<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType>
+  extends YatspPipe<A, B>,
+    core.$YatspCodec<A, B> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  _yatsp: core.$YatspCodecInternals<A, B>;
+  def: core.$YatspCodecDef<A, B>;
+}
+export const YatspCodec: core.$constructor<YatspCodec> = /*@__PURE__*/ core.$constructor("YatspCodec", (inst, def) => {
+  YatspPipe.init(inst, def);
+  core.$YatspCodec.init(inst, def);
+});
+
+export function codec<const A extends core.SomeType, B extends core.SomeType = core.$YatspType>(
+  in_: A,
+  out: B,
+  params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+  }
+): YatspCodec<A, B> {
+  return new YatspCodec({
+    type: "pipe",
+    in: in_ as any as core.$YatspType,
+    out: out as any as core.$YatspType,
+    transform: params.decode as any,
+    reverseTransform: params.encode as any,
+  }) as any;
+}
+
+export function invertCodec<A extends core.SomeType, B extends core.SomeType>(
+  codec: YatspCodec<A, B>
+): YatspCodec<B, A> {
+  const def = codec._yatsp.def;
+  return new YatspCodec({
+    type: "pipe",
+    in: def.out as any,
+    out: def.in as any,
+    transform: def.reverseTransform as any,
+    reverseTransform: def.transform as any,
+  }) as any;
+}
+
+// YatspPreprocess
+export interface YatspPreprocess<B extends core.SomeType = core.$YatspType, I = unknown>
+  extends YatspPipe<core.$YatspTransform<unknown, I>, B>,
+    core.$YatspPreprocess<B, I> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  _yatsp: core.$YatspPreprocessInternals<B, I>;
+  def: core.$YatspPreprocessDef<B, I>;
+}
+export const YatspPreprocess: core.$constructor<YatspPreprocess> = /*@__PURE__*/ core.$constructor(
+  "YatspPreprocess",
+  (inst, def) => {
+    YatspPipe.init(inst, def);
+    core.$YatspPreprocess.init(inst, def);
+  }
+);
+
+// YatspReadonly
+export interface YatspReadonly<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspReadonlyInternals<T>>,
+    core.$YatspReadonly<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspReadonly: core.$constructor<YatspReadonly> = /*@__PURE__*/ core.$constructor(
+  "YatspReadonly",
+  (inst, def) => {
+    core.$YatspReadonly.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.readonlyProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function readonly<T extends core.SomeType>(innerType: T): YatspReadonly<T> {
+  return new YatspReadonly({
+    type: "readonly",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspTemplateLiteral
+export interface YatspTemplateLiteral<Template extends string = string>
+  extends _YatspType<core.$YatspTemplateLiteralInternals<Template>>,
+    core.$YatspTemplateLiteral<Template> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspTemplateLiteral: core.$constructor<YatspTemplateLiteral> = /*@__PURE__*/ core.$constructor(
+  "YatspTemplateLiteral",
+  (inst, def) => {
+    core.$YatspTemplateLiteral.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.templateLiteralProcessor(inst, ctx, json, params);
+  }
+);
+
+export function templateLiteral<const Parts extends core.$YatspTemplateLiteralPart[]>(
+  parts: Parts,
+  params?: string | core.$YatspTemplateLiteralParams
+): YatspTemplateLiteral<core.$PartsToTemplateLiteral<Parts>> {
+  return new YatspTemplateLiteral({
+    type: "template_literal",
+    parts,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspLazy
+export interface YatspLazy<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspLazyInternals<T>>,
+    core.$YatspLazy<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspLazy: core.$constructor<YatspLazy> = /*@__PURE__*/ core.$constructor("YatspLazy", (inst, def) => {
+  core.$YatspLazy.init(inst, def);
+  YatspType.init(inst, def);
+  inst._yatsp.processJSONSchema = (ctx, json, params) => processors.lazyProcessor(inst, ctx, json, params);
+
+  inst.unwrap = () => inst._yatsp.def.getter();
+});
+
+export function lazy<T extends core.SomeType>(getter: () => T): YatspLazy<T> {
+  return new YatspLazy({
+    type: "lazy",
+    getter: getter as any,
+  }) as any;
+}
+
+// YatspPromise
+export interface YatspPromise<T extends core.SomeType = core.$YatspType>
+  extends _YatspType<core.$YatspPromiseInternals<T>>,
+    core.$YatspPromise<T> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export const YatspPromise: core.$constructor<YatspPromise> = /*@__PURE__*/ core.$constructor(
+  "YatspPromise",
+  (inst, def) => {
+    core.$YatspPromise.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.promiseProcessor(inst, ctx, json, params);
+
+    inst.unwrap = () => inst._yatsp.def.innerType;
+  }
+);
+
+export function promise<T extends core.SomeType>(innerType: T): YatspPromise<T> {
+  return new YatspPromise({
+    type: "promise",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspFunction
+export interface YatspFunction<
+  Args extends core.$YatspFunctionIn = core.$YatspFunctionIn,
+  Returns extends core.$YatspFunctionOut = core.$YatspFunctionOut,
+> extends _YatspType<core.$YatspFunctionInternals<Args, Returns>>,
+    core.$YatspFunction<Args, Returns> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+  _def: core.$YatspFunctionDef<Args, Returns>;
+  _input: core.$InferInnerFunctionType<Args, Returns>;
+  _output: core.$InferOuterFunctionType<Args, Returns>;
+
+  input<const Items extends util.TupleItems, const Rest extends core.$YatspFunctionOut = core.$YatspFunctionOut>(
+    args: Items,
+    rest?: Rest
+  ): YatspFunction<core.$YatspTuple<Items, Rest>, Returns>;
+  input<NewArgs extends core.$YatspFunctionIn>(args: NewArgs): YatspFunction<NewArgs, Returns>;
+  input(...args: any[]): YatspFunction<any, Returns>;
+
+  output<NewReturns extends core.$YatspType>(output: NewReturns): YatspFunction<Args, NewReturns>;
+}
+
+export const YatspFunction: core.$constructor<YatspFunction> = /*@__PURE__*/ core.$constructor(
+  "YatspFunction",
+  (inst, def) => {
+    core.$YatspFunction.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.functionProcessor(inst, ctx, json, params);
+  }
+);
+
+export function _function(): YatspFunction;
+export function _function<const In extends ReadonlyArray<core.$YatspType>>(params: {
+  input: In;
+}): YatspFunction<YatspTuple<In, null>, core.$YatspFunctionOut>;
+export function _function<
+  const In extends ReadonlyArray<core.$YatspType>,
+  const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut,
+>(params: {
+  input: In;
+  output: Out;
+}): YatspFunction<YatspTuple<In, null>, Out>;
+export function _function<const In extends core.$YatspFunctionIn = core.$YatspFunctionIn>(params: {
+  input: In;
+}): YatspFunction<In, core.$YatspFunctionOut>;
+export function _function<const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params: {
+  output: Out;
+}): YatspFunction<core.$YatspFunctionIn, Out>;
+export function _function<
+  In extends core.$YatspFunctionIn = core.$YatspFunctionIn,
+  Out extends core.$YatspType = core.$YatspType,
+>(params?: {
+  input: In;
+  output: Out;
+}): YatspFunction<In, Out>;
+export function _function(params?: {
+  output?: core.$YatspType;
+  input?: core.$YatspFunctionArgs | Array<core.$YatspType>;
+}): YatspFunction {
+  return new YatspFunction({
+    type: "function",
+    input: Array.isArray(params?.input) ? tuple(params?.input as any) : (params?.input ?? array(unknown())),
+    output: params?.output ?? unknown(),
+  });
+}
+
+export { _function as function };
+
+// YatspCustom
+export interface YatspCustom<O = unknown, I = unknown>
+  extends _YatspType<core.$YatspCustomInternals<O, I>>,
+    core.$YatspCustom<O, I> {
+  "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export const YatspCustom: core.$constructor<YatspCustom> = /*@__PURE__*/ core.$constructor(
+  "YatspCustom",
+  (inst, def) => {
+    core.$YatspCustom.init(inst, def);
+    YatspType.init(inst, def);
+    inst._yatsp.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
+  }
+);
+
+// custom checks
+export function check<O = unknown>(fn: core.CheckFn<O>): core.$YatspCheck<O> {
+  const ch = new core.$YatspCheck({
+    check: "custom",
+    // ...util.normalizeParams(params),
+  });
+
+  ch._yatsp.check = fn;
+  return ch;
+}
+
+export function custom<O>(
+  fn?: (data: unknown) => unknown,
+  _params?: string | core.$YatspCustomParams | undefined
+): YatspCustom<O, O> {
+  return core._custom(YatspCustom, fn ?? (() => true), _params) as any;
+}
+
+export function refine<T>(
+  fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
+  _params: string | core.$YatspCustomParams = {}
+): core.$YatspCheck<T> {
+  return core._refine(YatspCustom, fn, _params);
+}
+
+// superRefine
+export function superRefine<T>(
+  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>,
+  params?: core.$YatspSuperRefineParams
+): core.$YatspCheck<T> {
+  return core._superRefine(fn, params);
+}
+
+// Re-export describe and meta from core
+export const describe = core.describe;
+export const meta = core.meta;
+
+type YatspInstanceOfParams = core.Params<
+  YatspCustom,
+  core.$YatspIssueCustom,
+  "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path"
+>;
+
+// YatspInstanceOf
+export interface YatspInstanceOf<T = unknown> extends YatspCustom<T, T> {
+  // the shape is keyed off the instance type, so keys autocomplete and a schema that can't accept the property's type is an error. Methods are excluded: every object literal inherits Object.prototype.toString, which would otherwise collide with the constraint's own toString entry and reject every shape.
+  properties<Shape extends { [k in keyof T as T[k] extends Function ? never : k]?: core.$YatspType<unknown, T[k]> }>(
+    shape: Shape,
+    params?: string | core.$YatspCheckPropertiesParams
+  ): YatspInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+}
+export const YatspInstanceOf: core.$constructor<YatspInstanceOf> = /*@__PURE__*/ core.$constructor(
+  "YatspInstanceOf",
+  (inst, def) => {
+    YatspCustom.init(inst, def);
+  },
+  {
+    properties(shape: core.$YatspShape, params?: string | core.$YatspCheckPropertiesParams) {
+      // asserts in place, so the narrowed output type is truthful without a wrapper
+      return this.check(core._properties(shape, params)) as any;
+    },
+  }
+);
+
+function _instanceof<T extends typeof util.Class>(
+  cls: T,
+  params: YatspInstanceOfParams = {}
+): YatspInstanceOf<InstanceType<T>> {
+  const inst = new YatspInstanceOf({
+    type: "custom",
+    check: "custom",
+    fn: (data: unknown) => data instanceof cls,
+    abort: true,
+    ...(util.normalizeParams(params) as any),
+  });
+  inst._yatsp.bag.Class = cls;
+  // Override check to emit invalid_type instead of custom
+  inst._yatsp.check = (payload) => {
+    if (!(payload.value instanceof cls)) {
+      payload.issues.push({
+        code: "invalid_type",
+        expected: cls.name,
+        input: payload.value,
+        inst,
+        path: [...(inst._yatsp.def.path ?? [])],
+      });
+    }
+  };
+  return inst as any;
+}
+export { _instanceof as instanceof };
+
+// stringbool
+export const stringbool: (_params?: string | core.$YatspStringBoolParams) => YatspCodec<YatspString, YatspBoolean> = (
+  ...args
+) =>
+  core._stringbool(
+    {
+      Codec: YatspCodec,
+      Boolean: YatspBoolean,
+      String: YatspString,
+    },
+    ...args
+  ) as any;
+
+// json
+type _YatspJSONSchema = YatspUnion<
+  [
+    YatspString,
+    YatspNumber,
+    YatspBoolean,
+    YatspNull,
+    YatspArray<YatspJSONSchema>,
+    YatspRecord<YatspString, YatspJSONSchema>,
+  ]
+>;
+type _YatspJSONSchemaInternals = _YatspJSONSchema["_yatsp"];
+
+export interface YatspJSONSchemaInternals extends _YatspJSONSchemaInternals {
+  output: util.JSONType;
+  input: util.JSONType;
+}
+export interface YatspJSONSchema extends _YatspJSONSchema {
+  _yatsp: YatspJSONSchemaInternals;
+}
+
+export function json(params?: string | core.$YatspCustomParams): YatspJSONSchema {
+  const jsonSchema: any = lazy(() => {
+    return union([string(params), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);
+  });
+
+  return jsonSchema;
+}
+
+// preprocess
+
+export function preprocess<A, U extends core.SomeType, B = unknown>(
+  fn: (arg: B, ctx: core.$RefinementCtx) => A,
+  schema: U
+): YatspPreprocess<U, B> {
+  return new YatspPreprocess({
+    type: "pipe",
+    in: transform(fn as any) as any as core.$YatspTransform,
+    out: schema as any as core.$YatspType,
+  }) as any;
+}