@willaimg/yatsp 4.3.6

package/src/v4/mini/schemas.ts

@@ -0,0 +1,2093 @@
+import * as core from "../core/index.js";
+import type { $YatspBigIntFormats } from "../core/index.js";
+import * as regexes from "../core/regexes.js";
+import * as util from "../core/util.js";
+import * as parse from "./parse.js";
+
+type SomeType = core.SomeType;
+
+export interface YatspMiniType<
+  out Output = unknown,
+  out Input = unknown,
+  out Internals extends core.$YatspTypeInternals<Output, Input> = core.$YatspTypeInternals<Output, Input>,
+> extends core.$YatspType<Output, Input, Internals> {
+  type: Internals["def"]["type"];
+  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>;
+
+  def: Internals["def"];
+
+  parse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): core.output<this>;
+  safeParse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): util.SafeParseResult<core.output<this>>;
+  parseAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<core.output<this>>;
+  safeParseAsync(
+    data: unknown,
+    params?: core.ParseContext<core.$YatspIssue>
+  ): Promise<util.SafeParseResult<core.output<this>>>;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+
+interface _YatspMiniType<out Internals extends core.$YatspTypeInternals = core.$YatspTypeInternals>
+  extends YatspMiniType<any, any, Internals> {}
+
+export const YatspMiniType: core.$constructor<YatspMiniType> = /*@__PURE__*/ core.$constructor<YatspMiniType>(
+  "YatspMiniType",
+  (inst, def) => {
+    if (!inst._yatsp) throw new Error("Uninitialized schema in YatspMiniType.");
+
+    core.$YatspType.init(inst, def);
+
+    inst.def = def;
+    inst.type = def.type;
+  },
+  {
+    // `with` is an alias for `check`: the same function object, not a wrapper.
+    get with(): YatspMiniType["check"] {
+      return this.check;
+    },
+    set with(value: YatspMiniType["check"]) {
+      util.own(this, "with", value);
+    },
+    parse(data, params) {
+      return parse.parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+      return parse.parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+      return parse.safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+      return parse.safeParseAsync(this, data, params);
+    },
+    check(...checks) {
+      const def = this.def;
+      return this.clone(
+        {
+          ...def,
+          checks: [
+            ...(def.checks ?? []),
+            ...checks.map((ch) =>
+              typeof ch === "function" ? { _yatsp: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
+            ),
+          ],
+        },
+        { parent: true }
+      );
+    },
+    clone(_def, params) {
+      return core.clone(this, _def, params);
+    },
+    brand() {
+      return this as any;
+    },
+    register(reg: any, meta: any): any {
+      reg.add(this, meta);
+      return this;
+    },
+    apply(fn: any, ...args: any[]) {
+      return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
+  }
+);
+
+export interface _YatspMiniString<T extends core.$YatspStringInternals<unknown> = core.$YatspStringInternals<unknown>>
+  extends _YatspMiniType<T>,
+    core.$YatspString<T["input"]> {
+  _yatsp: T;
+}
+
+// YatspMiniString
+export interface YatspMiniString<Input = unknown>
+  extends _YatspMiniString<core.$YatspStringInternals<Input>>,
+    core.$YatspString<Input> {}
+export const YatspMiniString: core.$constructor<YatspMiniString> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniString",
+  (inst, def) => {
+    core.$YatspString.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function string(params?: string | core.$YatspStringParams): YatspMiniString<string> {
+  return core._string(YatspMiniString, params) as any;
+}
+
+// YatspMiniStringFormat
+export interface YatspMiniStringFormat<Format extends string = string>
+  extends _YatspMiniString<core.$YatspStringFormatInternals<Format>>,
+    core.$YatspStringFormat<Format> {
+  // _yatsp: core.$YatspStringFormatInternals<Format>;
+}
+export const YatspMiniStringFormat: core.$constructor<YatspMiniStringFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniStringFormat",
+  (inst, def) => {
+    core.$YatspStringFormat.init(inst, def);
+    YatspMiniString.init(inst, def);
+  }
+);
+
+// YatspMiniEmail
+export interface YatspMiniEmail extends _YatspMiniString<core.$YatspEmailInternals> {}
+export const YatspMiniEmail: core.$constructor<YatspMiniEmail> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniEmail",
+  (inst, def) => {
+    core.$YatspEmail.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function email(params?: string | core.$YatspEmailParams): YatspMiniEmail {
+  return core._email(YatspMiniEmail, params);
+}
+
+// YatspMiniGUID
+export interface YatspMiniGUID extends _YatspMiniString<core.$YatspGUIDInternals> {
+  // _yatsp: core.$YatspGUIDInternals;
+}
+export const YatspMiniGUID: core.$constructor<YatspMiniGUID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniGUID",
+  (inst, def) => {
+    core.$YatspGUID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function guid(params?: string | core.$YatspGUIDParams): YatspMiniGUID {
+  return core._guid(YatspMiniGUID, params);
+}
+
+// YatspMiniUUID
+export interface YatspMiniUUID extends _YatspMiniString<core.$YatspUUIDInternals> {
+  // _yatsp: core.$YatspUUIDInternals;
+}
+export const YatspMiniUUID: core.$constructor<YatspMiniUUID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniUUID",
+  (inst, def) => {
+    core.$YatspUUID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function uuid(params?: string | core.$YatspUUIDParams): YatspMiniUUID {
+  return core._uuid(YatspMiniUUID, params);
+}
+
+// @__NO_SIDE_EFFECTS__
+export function uuidv4(params?: string | core.$YatspUUIDv4Params): YatspMiniUUID {
+  return core._uuidv4(YatspMiniUUID, params);
+}
+
+// YatspMiniUUIDv6
+
+// @__NO_SIDE_EFFECTS__
+export function uuidv6(params?: string | core.$YatspUUIDv6Params): YatspMiniUUID {
+  return core._uuidv6(YatspMiniUUID, params);
+}
+
+// YatspMiniUUIDv7
+
+// @__NO_SIDE_EFFECTS__
+export function uuidv7(params?: string | core.$YatspUUIDv7Params): YatspMiniUUID {
+  return core._uuidv7(YatspMiniUUID, params);
+}
+
+// YatspMiniURL
+export interface YatspMiniURL extends _YatspMiniString<core.$YatspURLInternals> {
+  // _yatsp: core.$YatspURLInternals;
+}
+export const YatspMiniURL: core.$constructor<YatspMiniURL> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniURL",
+  (inst, def) => {
+    core.$YatspURL.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function url(params?: string | core.$YatspURLParams): YatspMiniURL {
+  return core._url(YatspMiniURL, params);
+}
+
+// @__NO_SIDE_EFFECTS__
+export function httpUrl(params?: string | Omit<core.$YatspURLParams, "protocol" | "hostname">): YatspMiniURL {
+  return core._url(YatspMiniURL, {
+    protocol: regexes.httpProtocol,
+    hostname: regexes.domain,
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspMiniEmoji
+export interface YatspMiniEmoji extends _YatspMiniString<core.$YatspEmojiInternals> {
+  // _yatsp: core.$YatspEmojiInternals;
+}
+export const YatspMiniEmoji: core.$constructor<YatspMiniEmoji> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniEmoji",
+  (inst, def) => {
+    core.$YatspEmoji.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function emoji(params?: string | core.$YatspEmojiParams): YatspMiniEmoji {
+  return core._emoji(YatspMiniEmoji, params);
+}
+
+// YatspMiniNanoID
+export interface YatspMiniNanoID extends _YatspMiniString<core.$YatspNanoIDInternals> {
+  // _yatsp: core.$YatspNanoIDInternals;
+}
+export const YatspMiniNanoID: core.$constructor<YatspMiniNanoID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNanoID",
+  (inst, def) => {
+    core.$YatspNanoID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function nanoid(params?: string | core.$YatspNanoIDParams): YatspMiniNanoID {
+  return core._nanoid(YatspMiniNanoID, params);
+}
+
+// YatspMiniCUID
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspMiniCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export interface YatspMiniCUID extends _YatspMiniString<core.$YatspCUIDInternals> {
+  // _yatsp: core.$YatspCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspMiniCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export const YatspMiniCUID: core.$constructor<YatspMiniCUID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCUID",
+  (inst, def) => {
+    core.$YatspCUID.init(inst, def);
+    YatspMiniStringFormat.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.
+ */
+// @__NO_SIDE_EFFECTS__
+export function cuid(params?: string | core.$YatspCUIDParams): YatspMiniCUID {
+  return core._cuid(YatspMiniCUID, params);
+}
+
+// YatspMiniCUID2
+export interface YatspMiniCUID2 extends _YatspMiniString<core.$YatspCUID2Internals> {
+  // _yatsp: core.$YatspCUID2Internals;
+}
+export const YatspMiniCUID2: core.$constructor<YatspMiniCUID2> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCUID2",
+  (inst, def) => {
+    core.$YatspCUID2.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function cuid2(params?: string | core.$YatspCUID2Params): YatspMiniCUID2 {
+  return core._cuid2(YatspMiniCUID2, params);
+}
+
+// YatspMiniULID
+export interface YatspMiniULID extends _YatspMiniString<core.$YatspULIDInternals> {
+  // _yatsp: core.$YatspULIDInternals;
+}
+export const YatspMiniULID: core.$constructor<YatspMiniULID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniULID",
+  (inst, def) => {
+    core.$YatspULID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function ulid(params?: string | core.$YatspULIDParams): YatspMiniULID {
+  return core._ulid(YatspMiniULID, params);
+}
+
+// YatspMiniXID
+export interface YatspMiniXID extends _YatspMiniString<core.$YatspXIDInternals> {
+  // _yatsp: core.$YatspXIDInternals;
+}
+export const YatspMiniXID: core.$constructor<YatspMiniXID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniXID",
+  (inst, def) => {
+    core.$YatspXID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function xid(params?: string | core.$YatspXIDParams): YatspMiniXID {
+  return core._xid(YatspMiniXID, params);
+}
+
+// YatspMiniKSUID
+export interface YatspMiniKSUID extends _YatspMiniString<core.$YatspKSUIDInternals> {
+  // _yatsp: core.$YatspKSUIDInternals;
+}
+export const YatspMiniKSUID: core.$constructor<YatspMiniKSUID> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniKSUID",
+  (inst, def) => {
+    core.$YatspKSUID.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function ksuid(params?: string | core.$YatspKSUIDParams): YatspMiniKSUID {
+  return core._ksuid(YatspMiniKSUID, params);
+}
+
+// YatspMiniIPv4
+export interface YatspMiniIPv4 extends _YatspMiniString<core.$YatspIPv4Internals> {
+  // _yatsp: core.$YatspIPv4Internals;
+}
+export const YatspMiniIPv4: core.$constructor<YatspMiniIPv4> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniIPv4",
+  (inst, def) => {
+    core.$YatspIPv4.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function ipv4(params?: string | core.$YatspIPv4Params): YatspMiniIPv4 {
+  return core._ipv4(YatspMiniIPv4, params);
+}
+
+// YatspMiniIPv6
+export interface YatspMiniIPv6 extends _YatspMiniString<core.$YatspIPv6Internals> {
+  // _yatsp: core.$YatspIPv6Internals;
+}
+export const YatspMiniIPv6: core.$constructor<YatspMiniIPv6> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniIPv6",
+  (inst, def) => {
+    core.$YatspIPv6.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function ipv6(params?: string | core.$YatspIPv6Params): YatspMiniIPv6 {
+  return core._ipv6(YatspMiniIPv6, params);
+}
+
+// YatspMiniCIDRv4
+export interface YatspMiniCIDRv4 extends _YatspMiniString<core.$YatspCIDRv4Internals> {
+  // _yatsp: core.$YatspCIDRv4Internals;
+}
+export const YatspMiniCIDRv4: core.$constructor<YatspMiniCIDRv4> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCIDRv4",
+  (inst, def) => {
+    core.$YatspCIDRv4.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function cidrv4(params?: string | core.$YatspCIDRv4Params): YatspMiniCIDRv4 {
+  return core._cidrv4(YatspMiniCIDRv4, params);
+}
+
+// YatspMiniCIDRv6
+export interface YatspMiniCIDRv6 extends _YatspMiniString<core.$YatspCIDRv6Internals> {
+  // _yatsp: core.$YatspCIDRv6Internals;
+}
+export const YatspMiniCIDRv6: core.$constructor<YatspMiniCIDRv6> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCIDRv6",
+  (inst, def) => {
+    core.$YatspCIDRv6.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function cidrv6(params?: string | core.$YatspCIDRv6Params): YatspMiniCIDRv6 {
+  return core._cidrv6(YatspMiniCIDRv6, params);
+}
+
+// YatspMiniMAC
+export interface YatspMiniMAC extends _YatspMiniString<core.$YatspMACInternals> {
+  // _yatsp: core.$YatspMACInternals;
+}
+export const YatspMiniMAC: core.$constructor<YatspMiniMAC> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniMAC",
+  (inst, def) => {
+    core.$YatspMAC.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function mac(params?: string | core.$YatspMACParams): YatspMiniMAC {
+  return core._mac(YatspMiniMAC, params);
+}
+
+// YatspMiniBase64
+export interface YatspMiniBase64 extends _YatspMiniString<core.$YatspBase64Internals> {
+  // _yatsp: core.$YatspBase64Internals;
+}
+export const YatspMiniBase64: core.$constructor<YatspMiniBase64> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniBase64",
+  (inst, def) => {
+    core.$YatspBase64.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+// @__NO_SIDE_EFFECTS__
+export function base64(params?: string | core.$YatspBase64Params): YatspMiniBase64 {
+  return core._base64(YatspMiniBase64, params);
+}
+
+// YatspMiniBase64URL
+export interface YatspMiniBase64URL extends _YatspMiniString<core.$YatspBase64URLInternals> {
+  // _yatsp: core.$YatspBase64URLInternals;
+}
+export const YatspMiniBase64URL: core.$constructor<YatspMiniBase64URL> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniBase64URL",
+  (inst, def) => {
+    core.$YatspBase64URL.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+// @__NO_SIDE_EFFECTS__
+export function base64url(params?: string | core.$YatspBase64URLParams): YatspMiniBase64URL {
+  return core._base64url(YatspMiniBase64URL, params);
+}
+
+// YatspMiniE164
+export interface YatspMiniE164 extends _YatspMiniString<core.$YatspE164Internals> {
+  // _yatsp: core.$YatspE164Internals;
+}
+export const YatspMiniE164: core.$constructor<YatspMiniE164> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniE164",
+  (inst, def) => {
+    core.$YatspE164.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function e164(params?: string | core.$YatspE164Params): YatspMiniE164 {
+  return core._e164(YatspMiniE164, params);
+}
+
+// YatspMiniCreditCard
+export interface YatspMiniCreditCard extends _YatspMiniString<core.$YatspCreditCardInternals> {}
+export const YatspMiniCreditCard: core.$constructor<YatspMiniCreditCard> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCreditCard",
+  (inst, def) => {
+    core.$YatspCreditCard.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function creditCard(params?: string | core.$YatspCreditCardParams): YatspMiniCreditCard {
+  return core._creditCard(YatspMiniCreditCard, params);
+}
+
+// YatspMiniIBAN
+export interface YatspMiniIBAN extends _YatspMiniString<core.$YatspIBANInternals> {}
+export const YatspMiniIBAN: core.$constructor<YatspMiniIBAN> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniIBAN",
+  (inst, def) => {
+    core.$YatspIBAN.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function iban(params?: string | core.$YatspIBANParams): YatspMiniIBAN {
+  return core._iban(YatspMiniIBAN, params);
+}
+
+// YatspMiniJWT
+export interface YatspMiniJWT extends _YatspMiniString<core.$YatspJWTInternals> {
+  // _yatsp: core.$YatspJWTInternals;
+}
+export const YatspMiniJWT: core.$constructor<YatspMiniJWT> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniJWT",
+  (inst, def) => {
+    core.$YatspJWT.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function jwt(params?: string | core.$YatspJWTParams): YatspMiniJWT {
+  return core._jwt(YatspMiniJWT, params);
+}
+
+// YatspMiniCustomStringFormat
+export interface YatspMiniCustomStringFormat<Format extends string = string>
+  extends YatspMiniStringFormat<Format>,
+    core.$YatspCustomStringFormat<Format> {
+  _yatsp: core.$YatspCustomStringFormatInternals<Format>;
+}
+export const YatspMiniCustomStringFormat: core.$constructor<YatspMiniCustomStringFormat> =
+  /*@__PURE__*/ core.$constructor("YatspMiniCustomStringFormat", (inst, def) => {
+    core.$YatspCustomStringFormat.init(inst, def);
+    YatspMiniStringFormat.init(inst, def);
+  });
+
+// @__NO_SIDE_EFFECTS__
+export function stringFormat<Format extends string>(
+  format: Format,
+  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,
+  _params: string | core.$YatspStringFormatParams = {}
+): YatspMiniCustomStringFormat<Format> {
+  return core._stringFormat(YatspMiniCustomStringFormat, format, fnOrRegex, _params) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function hostname(_params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<"hostname"> {
+  return core._stringFormat(YatspMiniCustomStringFormat, "hostname", regexes.hostname, _params) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function hex(_params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<"hex"> {
+  return core._stringFormat(YatspMiniCustomStringFormat, "hex", regexes.hex, _params) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function currencyCode(
+  _params?: string | core.$YatspStringFormatParams
+): YatspMiniCustomStringFormat<"currency_code"> {
+  return core._stringFormat(YatspMiniCustomStringFormat, "currency_code", regexes.currencyCode, _params) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(
+  alg: Alg,
+  params?: {
+    enc?: Enc;
+  } & core.$YatspStringFormatParams
+): YatspMiniCustomStringFormat<`${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;
+  // check for unrecognized format
+  if (!regex) throw new Error(`Unrecognized hash format: ${format}`);
+  return core._stringFormat(YatspMiniCustomStringFormat, format, regex, params) as any;
+}
+
+// YatspMiniNumber
+interface _YatspMiniNumber<T extends core.$YatspNumberInternals<unknown> = core.$YatspNumberInternals<unknown>>
+  extends _YatspMiniType<T>,
+    core.$YatspNumber<T["input"]> {
+  _yatsp: T;
+}
+export interface YatspMiniNumber<Input = unknown>
+  extends _YatspMiniNumber<core.$YatspNumberInternals<Input>>,
+    core.$YatspNumber<Input> {}
+export const YatspMiniNumber: core.$constructor<YatspMiniNumber> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNumber",
+  (inst, def) => {
+    core.$YatspNumber.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function number(params?: string | core.$YatspNumberParams): YatspMiniNumber<number> {
+  return core._number(YatspMiniNumber, params) as any;
+}
+
+// YatspMiniNumberFormat
+export interface YatspMiniNumberFormat<Format extends core.$YatspNumberFormats = core.$YatspNumberFormats>
+  extends _YatspMiniNumber<core.$YatspNumberFormatInternals<Format>>,
+    core.$YatspNumberFormat<Format> {}
+export const YatspMiniNumberFormat: core.$constructor<YatspMiniNumberFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNumberFormat",
+  (inst, def) => {
+    core.$YatspNumberFormat.init(inst, def);
+    YatspMiniNumber.init(inst, def);
+  }
+);
+
+// int
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniInt extends YatspMiniNumberFormat<"safeint"> {}
+export function int(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniInt {
+  return core._int(YatspMiniNumberFormat, params) as YatspMiniInt;
+}
+
+// float32
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniFloat32 extends YatspMiniNumberFormat<"float32"> {}
+export function float32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniFloat32 {
+  return core._float32(YatspMiniNumberFormat, params) as YatspMiniFloat32;
+}
+
+// float64
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniFloat64 extends YatspMiniNumberFormat<"float64"> {}
+export function float64(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniFloat64 {
+  return core._float64(YatspMiniNumberFormat, params) as YatspMiniFloat64;
+}
+
+// int32
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniInt32 extends YatspMiniNumberFormat<"int32"> {}
+export function int32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniInt32 {
+  return core._int32(YatspMiniNumberFormat, params) as YatspMiniInt32;
+}
+
+// uint32
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniUInt32 extends YatspMiniNumberFormat<"uint32"> {}
+export function uint32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniUInt32 {
+  return core._uint32(YatspMiniNumberFormat, params) as YatspMiniUInt32;
+}
+
+// YatspMiniBoolean
+export interface YatspMiniBoolean<T = unknown> extends _YatspMiniType<core.$YatspBooleanInternals<T>> {
+  // _yatsp: core.$YatspBooleanInternals<T>;
+}
+export const YatspMiniBoolean: core.$constructor<YatspMiniBoolean> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniBoolean",
+  (inst, def) => {
+    core.$YatspBoolean.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function boolean(params?: string | core.$YatspBooleanParams): YatspMiniBoolean<boolean> {
+  return core._boolean(YatspMiniBoolean, params) as any;
+}
+
+// YatspMiniBigInt
+export interface YatspMiniBigInt<T = unknown>
+  extends _YatspMiniType<core.$YatspBigIntInternals<T>>,
+    core.$YatspBigInt<T> {
+  // _yatsp: core.$YatspBigIntInternals<T>;
+}
+export const YatspMiniBigInt: core.$constructor<YatspMiniBigInt> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniBigInt",
+  (inst, def) => {
+    core.$YatspBigInt.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function bigint(params?: string | core.$YatspBigIntParams): YatspMiniBigInt<bigint> {
+  return core._bigint(YatspMiniBigInt, params) as any;
+}
+
+// bigint formats
+
+// YatspMiniBigIntFormat
+export interface YatspMiniBigIntFormat<Format extends $YatspBigIntFormats = $YatspBigIntFormats>
+  extends _YatspMiniType<core.$YatspBigIntFormatInternals<Format>> {
+  // _yatsp: core.$YatspBigIntFormatInternals<Format>;
+}
+export const YatspMiniBigIntFormat: core.$constructor<YatspMiniBigIntFormat> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniBigIntFormat",
+  (inst, def) => {
+    core.$YatspBigIntFormat.init(inst, def);
+    YatspMiniBigInt.init(inst, def);
+  }
+);
+
+// int64
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniInt64 extends YatspMiniBigIntFormat<"int64"> {}
+export function int64(params?: string | core.$YatspBigIntFormatParams): YatspMiniInt64 {
+  return core._int64(YatspMiniBigIntFormat, params) as YatspMiniInt64;
+}
+
+// uint64
+
+// @__NO_SIDE_EFFECTS__
+export interface YatspMiniUInt64 extends YatspMiniBigIntFormat<"uint64"> {}
+export function uint64(params?: string | core.$YatspBigIntFormatParams): YatspMiniUInt64 {
+  return core._uint64(YatspMiniBigIntFormat, params) as YatspMiniUInt64;
+}
+
+// YatspMiniSymbol
+export interface YatspMiniSymbol extends _YatspMiniType<core.$YatspSymbolInternals> {
+  // _yatsp: core.$YatspSymbolInternals;
+}
+export const YatspMiniSymbol: core.$constructor<YatspMiniSymbol> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniSymbol",
+  (inst, def) => {
+    core.$YatspSymbol.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function symbol(params?: string | core.$YatspSymbolParams): YatspMiniSymbol {
+  return core._symbol(YatspMiniSymbol, params) as any;
+}
+
+// YatspMiniUndefined
+export interface YatspMiniUndefined extends _YatspMiniType<core.$YatspUndefinedInternals> {
+  // _yatsp: core.$YatspUndefinedInternals;
+}
+export const YatspMiniUndefined: core.$constructor<YatspMiniUndefined> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniUndefined",
+  (inst, def) => {
+    core.$YatspUndefined.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+function _undefined(params?: string | core.$YatspUndefinedParams): YatspMiniUndefined {
+  return core._undefined(YatspMiniUndefined, params) as any;
+}
+export { _undefined as undefined };
+
+// YatspMiniNull
+export interface YatspMiniNull extends _YatspMiniType<core.$YatspNullInternals> {
+  // _yatsp: core.$YatspNullInternals;
+}
+export const YatspMiniNull: core.$constructor<YatspMiniNull> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNull",
+  (inst, def) => {
+    core.$YatspNull.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+function _null(params?: string | core.$YatspNullParams): YatspMiniNull {
+  return core._null(YatspMiniNull, params) as any;
+}
+export { _null as null };
+
+// YatspMiniAny
+export interface YatspMiniAny extends _YatspMiniType<core.$YatspAnyInternals> {
+  // _yatsp: core.$YatspAnyInternals;
+}
+export const YatspMiniAny: core.$constructor<YatspMiniAny> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniAny",
+  (inst, def) => {
+    core.$YatspAny.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function any(): YatspMiniAny {
+  return core._any(YatspMiniAny) as any;
+}
+
+// YatspMiniUnknown
+export interface YatspMiniUnknown extends _YatspMiniType<core.$YatspUnknownInternals> {
+  // _yatsp: core.$YatspUnknownInternals;
+}
+export const YatspMiniUnknown: core.$constructor<YatspMiniUnknown> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniUnknown",
+  (inst, def) => {
+    core.$YatspUnknown.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function unknown(): YatspMiniUnknown {
+  return core._unknown(YatspMiniUnknown) as any;
+}
+
+// YatspMiniNever
+export interface YatspMiniNever extends _YatspMiniType<core.$YatspNeverInternals> {
+  // _yatsp: core.$YatspNeverInternals;
+}
+export const YatspMiniNever: core.$constructor<YatspMiniNever> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNever",
+  (inst, def) => {
+    core.$YatspNever.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function never(params?: string | core.$YatspNeverParams): YatspMiniNever {
+  return core._never(YatspMiniNever, params) as any;
+}
+
+// YatspMiniVoid
+export interface YatspMiniVoid extends _YatspMiniType<core.$YatspVoidInternals> {
+  // _yatsp: core.$YatspVoidInternals;
+}
+export const YatspMiniVoid: core.$constructor<YatspMiniVoid> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniVoid",
+  (inst, def) => {
+    core.$YatspVoid.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+function _void(params?: string | core.$YatspVoidParams): YatspMiniVoid {
+  return core._void(YatspMiniVoid, params) as any;
+}
+export { _void as void };
+
+// YatspMiniDate
+export interface YatspMiniDate<T = unknown> extends _YatspMiniType<core.$YatspDateInternals<T>> {
+  // _yatsp: core.$YatspDateInternals<T>;
+}
+
+export const YatspMiniDate: core.$constructor<YatspMiniDate> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniDate",
+  (inst, def) => {
+    core.$YatspDate.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function date(params?: string | core.$YatspDateParams): YatspMiniDate<Date> {
+  return core._date(YatspMiniDate, params) as any;
+}
+
+// YatspMiniArray
+export interface YatspMiniArray<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspArrayInternals<T>>,
+    core.$YatspArray<T> {
+  // _yatsp: core.$YatspArrayInternals<T>;
+}
+export const YatspMiniArray: core.$constructor<YatspMiniArray> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniArray",
+  (inst, def) => {
+    core.$YatspArray.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+export function array<T extends SomeType>(element: T, params?: string | core.$YatspArrayParams): YatspMiniArray<T>;
+// @__NO_SIDE_EFFECTS__
+export function array<T extends SomeType>(element: SomeType, params?: any): YatspMiniArray<T> {
+  return new YatspMiniArray({
+    type: "array",
+    element: element as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// .keyof
+// @__NO_SIDE_EFFECTS__
+export function keyof<T extends YatspMiniObject>(schema: T): YatspMiniEnum<util.KeysEnum<T["shape"]>> {
+  const shape = schema._yatsp.def.shape;
+  return _enum(Object.keys(shape)) as any;
+}
+
+// YatspMiniObject
+export interface YatspMiniObject<
+  /** @ts-ignore Cast variance */
+  out Shape extends core.$YatspShape = core.$YatspShape,
+  out Config extends core.$YatspObjectConfig = core.$strip,
+> extends YatspMiniType<any, any, core.$YatspObjectInternals<Shape, Config>>,
+    core.$YatspObject<Shape, Config> {
+  shape: Shape;
+}
+export const YatspMiniObject: core.$constructor<YatspMiniObject> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniObject",
+  (inst, def) => {
+    core.$YatspObject.init(inst, def);
+    YatspMiniType.init(inst, def);
+    util.installLazyProp(inst, "shape", (self) => self._yatsp.def.shape, false);
+  }
+);
+// @__NO_SIDE_EFFECTS__
+export function object<T extends core.$YatspLooseShape = Record<never, SomeType>>(
+  shape?: T,
+  params?: string | core.$YatspObjectParams
+): YatspMiniObject<util.Writeable<T>, core.$strip> {
+  const def: core.$YatspObjectDef = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params),
+  };
+  return new YatspMiniObject(def) as any;
+}
+
+// strictObject
+// @__NO_SIDE_EFFECTS__
+export function strictObject<T extends core.$YatspLooseShape>(
+  shape: T,
+  params?: string | core.$YatspObjectParams
+): YatspMiniObject<util.Writeable<T>, core.$strict> {
+  return new YatspMiniObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// looseObject
+// @__NO_SIDE_EFFECTS__
+export function looseObject<T extends core.$YatspLooseShape>(
+  shape: T,
+  params?: string | core.$YatspObjectParams
+): YatspMiniObject<util.Writeable<T>, core.$loose> {
+  return new YatspMiniObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// object methods
+// @__NO_SIDE_EFFECTS__
+export function extend<T extends YatspMiniObject, U extends core.$YatspLooseShape>(
+  schema: T,
+  shape: U
+): YatspMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_yatsp"]["config"]> {
+  return util.extend(schema, shape);
+}
+
+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];
+};
+
+// @__NO_SIDE_EFFECTS__
+export function safeExtend<T extends YatspMiniObject, U extends core.$YatspLooseShape>(
+  schema: T,
+  shape: SafeExtendShape<T["shape"], U>
+): YatspMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_yatsp"]["config"]> {
+  return util.safeExtend(schema, shape as any);
+}
+
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://yatsp.dev/api?id=extend) instead.
+ */
+// @__NO_SIDE_EFFECTS__
+export function merge<T extends YatspMiniObject, U extends YatspMiniObject>(
+  a: T,
+  b: U
+): YatspMiniObject<util.Extend<T["shape"], U["shape"]>, U["_yatsp"]["config"]> {
+  return util.merge(a, b) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function pick<T extends YatspMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): YatspMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_yatsp"]["config"]> {
+  return util.pick(schema, mask as any);
+}
+
+// .omit
+
+// @__NO_SIDE_EFFECTS__
+export function omit<T extends YatspMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): YatspMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_yatsp"]["config"]> {
+  return util.omit(schema, mask);
+}
+
+// @__NO_SIDE_EFFECTS__
+export function partial<T extends YatspMiniObject>(
+  schema: T
+): YatspMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: YatspMiniOptional<T["shape"][k]>;
+  },
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function partial<T extends YatspMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): YatspMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? YatspMiniOptional<T["shape"][k]> : T["shape"][k];
+  },
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function partial<T extends util.TupleItems, Rest extends SomeType | null>(
+  schema: YatspMiniTuple<T, Rest>
+): YatspMiniTuple<{ -readonly [k in keyof T]: YatspMiniOptional<T[k]> }, Rest>;
+// @__NO_SIDE_EFFECTS__
+export function partial(schema: YatspMiniObject | YatspMiniTuple, mask?: object) {
+  const def = schema._yatsp.def;
+  if (def.type !== "tuple") return util.partial(YatspMiniOptional, schema as YatspMiniObject, mask);
+  // 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 util.clone(schema, {
+    ...def,
+    items: def.items.map((item) => new YatspMiniOptional({ type: "optional", innerType: item as core.$YatspType })),
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function exactPartial<T extends YatspMiniObject>(
+  schema: T
+): YatspMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: YatspMiniExactOptional<T["shape"][k]>;
+  },
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function exactPartial<T extends YatspMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): YatspMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? YatspMiniExactOptional<T["shape"][k]> : T["shape"][k];
+  },
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function exactPartial(schema: YatspMiniObject, mask?: object) {
+  return util.partial(YatspMiniExactOptional, schema, mask, "exactPartial");
+}
+
+export type RequiredInterfaceShape<
+  Shape extends core.$YatspLooseShape,
+  Keys extends PropertyKey = keyof Shape,
+> = util.Identity<
+  {
+    [k in keyof Shape as k extends Keys ? k : never]: YatspMiniNonOptional<Shape[k]>;
+  } & {
+    [k in keyof Shape as k extends Keys ? never : k]: Shape[k];
+  }
+>;
+
+// @__NO_SIDE_EFFECTS__
+export function required<T extends YatspMiniObject>(
+  schema: T
+): YatspMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: YatspMiniNonOptional<T["shape"][k]>;
+  },
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function required<T extends YatspMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): YatspMiniObject<
+  util.Extend<
+    T["shape"],
+    {
+      [k in keyof M & keyof T["shape"]]: YatspMiniNonOptional<T["shape"][k]>;
+    }
+  >,
+  T["_yatsp"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function required(schema: YatspMiniObject, mask?: object) {
+  return util.required(YatspMiniNonOptional, schema, mask);
+}
+
+// @__NO_SIDE_EFFECTS__
+export function catchall<T extends YatspMiniObject, U extends SomeType>(
+  inst: T,
+  catchall: U
+): YatspMiniObject<T["shape"], core.$catchall<U>> {
+  // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree
+  return inst.clone(util.mergeDefs(inst._yatsp.def, { catchall: catchall as any })) as any;
+}
+
+// YatspMiniUnion
+export interface YatspMiniUnion<T extends readonly SomeType[] = readonly core.$YatspType[]>
+  extends _YatspMiniType<core.$YatspUnionInternals<T>> {
+  // _yatsp: core.$YatspUnionInternals<T>;
+}
+export const YatspMiniUnion: core.$constructor<YatspMiniUnion> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniUnion",
+  (inst, def) => {
+    core.$YatspUnion.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function union<const T extends readonly SomeType[]>(
+  options: T,
+  params?: string | core.$YatspUnionParams
+): YatspMiniUnion<T> {
+  return new YatspMiniUnion({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniXor
+export interface YatspMiniXor<T extends readonly SomeType[] = readonly core.$YatspType[]>
+  extends _YatspMiniType<core.$YatspXorInternals<T>> {
+  // _yatsp: core.$YatspXorInternals<T>;
+}
+export const YatspMiniXor: core.$constructor<YatspMiniXor> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniXor",
+  (inst, def) => {
+    YatspMiniUnion.init(inst, def);
+    core.$YatspXor.init(inst, def);
+  }
+);
+
+/** 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 SomeType[]>(
+  options: T,
+  params?: string | core.$YatspXorParams
+): YatspMiniXor<T> {
+  return new YatspMiniXor({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniDiscriminatedUnion
+export interface YatspMiniDiscriminatedUnion<
+  Options extends readonly SomeType[] = readonly core.$YatspType[],
+  Disc extends string = string,
+> extends YatspMiniUnion<Options> {
+  _yatsp: core.$YatspDiscriminatedUnionInternals<Options, Disc>;
+}
+export const YatspMiniDiscriminatedUnion: core.$constructor<YatspMiniDiscriminatedUnion> =
+  /*@__PURE__*/ core.$constructor("YatspMiniDiscriminatedUnion", (inst, def) => {
+    core.$YatspDiscriminatedUnion.init(inst, def);
+    YatspMiniType.init(inst, def);
+  });
+
+// @__NO_SIDE_EFFECTS__
+export function discriminatedUnion<
+  Types extends readonly [core.$YatspTypeDiscriminable, ...core.$YatspTypeDiscriminable[]],
+  Disc extends string,
+>(
+  discriminator: Disc,
+  options: Types,
+  params?: string | core.$YatspDiscriminatedUnionParams
+): YatspMiniDiscriminatedUnion<Types, Disc> {
+  return new YatspMiniDiscriminatedUnion({
+    type: "union",
+    options: options as any as core.$YatspType[],
+    discriminator,
+    ...util.normalizeParams(params),
+  }) as any as YatspMiniDiscriminatedUnion<Types, Disc>;
+}
+
+// YatspMiniIntersection
+export interface YatspMiniIntersection<A extends SomeType = core.$YatspType, B extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspIntersectionInternals<A, B>> {
+  // _yatsp: core.$YatspIntersectionInternals<A, B>;
+}
+export const YatspMiniIntersection: core.$constructor<YatspMiniIntersection> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniIntersection",
+  (inst, def) => {
+    core.$YatspIntersection.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): YatspMiniIntersection<T, U> {
+  return new YatspMiniIntersection({
+    type: "intersection",
+    left: left as any as core.$YatspType,
+    right: right as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniTuple
+export interface YatspMiniTuple<
+  T extends util.TupleItems = readonly core.$YatspType[],
+  Rest extends SomeType | null = core.$YatspType | null,
+> extends _YatspMiniType<core.$YatspTupleInternals<T, Rest>> {
+  // _yatsp: core.$YatspTupleInternals<T, Rest>;
+}
+export const YatspMiniTuple: core.$constructor<YatspMiniTuple> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniTuple",
+  (inst, def) => {
+    core.$YatspTuple.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+export function tuple<const T extends readonly [SomeType, ...SomeType[]]>(
+  items: T,
+  params?: string | core.$YatspTupleParams
+): YatspMiniTuple<T, null>;
+export function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(
+  items: T,
+  rest: Rest,
+  params?: string | core.$YatspTupleParams
+): YatspMiniTuple<T, Rest>;
+export function tuple(items: [], params?: string | core.$YatspTupleParams): YatspMiniTuple<[], null>;
+// @__NO_SIDE_EFFECTS__
+export function tuple(
+  items: SomeType[],
+  _paramsOrRest?: string | core.$YatspTupleParams | SomeType,
+  _params?: string | core.$YatspTupleParams
+) {
+  const hasRest = _paramsOrRest instanceof core.$YatspType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new YatspMiniTuple({
+    type: "tuple",
+    items: items as any as core.$YatspType[],
+    rest,
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspMiniRecord
+export interface YatspMiniRecord<
+  Key extends core.$YatspRecordKey = core.$YatspRecordKey,
+  Value extends SomeType = core.$YatspType,
+> extends _YatspMiniType<core.$YatspRecordInternals<Key, Value>> {
+  // _yatsp: core.$YatspRecordInternals<Key, Value>;
+}
+export const YatspMiniRecord: core.$constructor<YatspMiniRecord> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniRecord",
+  (inst, def) => {
+    core.$YatspRecord.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function record<Key extends core.$YatspRecordKey, Value extends SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspMiniRecord<Key, Value> {
+  // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()
+  if (!valueType || !(valueType as any)._yatsp) {
+    return new YatspMiniRecord({
+      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 YatspMiniRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+// @__NO_SIDE_EFFECTS__
+export function partialRecord<Key extends core.$YatspRecordKey, Value extends SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspMiniRecord<Key & core.$partial, Value> {
+  return new YatspMiniRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any,
+    ...util.normalizeParams(params),
+    partial: true,
+  }) as any;
+}
+
+export function looseRecord<Key extends core.$YatspRecordKey, Value extends SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspRecordParams
+): YatspMiniRecord<Key, Value> {
+  return new YatspMiniRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any as core.$YatspType,
+    mode: "loose",
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniMap
+export interface YatspMiniMap<Key extends SomeType = core.$YatspType, Value extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspMapInternals<Key, Value>> {
+  // _yatsp: core.$YatspMapInternals<Key, Value>;
+}
+export const YatspMiniMap: core.$constructor<YatspMiniMap> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniMap",
+  (inst, def) => {
+    core.$YatspMap.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function map<Key extends SomeType, Value extends SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$YatspMapParams
+): YatspMiniMap<Key, Value> {
+  return new YatspMiniMap({
+    type: "map",
+    keyType: keyType as any as core.$YatspType,
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniSet
+export interface YatspMiniSet<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspSetInternals<T>> {
+  // _yatsp: core.$YatspSetInternals<T>;
+}
+export const YatspMiniSet: core.$constructor<YatspMiniSet> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniSet",
+  (inst, def) => {
+    core.$YatspSet.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function set<Value extends SomeType>(
+  valueType: Value,
+  params?: string | core.$YatspSetParams
+): YatspMiniSet<Value> {
+  return new YatspMiniSet({
+    type: "set",
+    valueType: valueType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniEnum
+export interface YatspMiniEnum<T extends util.EnumLike = util.EnumLike>
+  extends _YatspMiniType<core.$YatspEnumInternals<T>> {
+  // _yatsp: core.$YatspEnumInternals<T>;
+  options: Array<T[keyof T]>;
+}
+export const YatspMiniEnum: core.$constructor<YatspMiniEnum> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniEnum",
+  (inst, def) => {
+    core.$YatspEnum.init(inst, def);
+    YatspMiniType.init(inst, def);
+
+    // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out
+    inst.options = [...inst._yatsp.values] as util.EnumValue[];
+  }
+);
+
+function _enum<const T extends readonly string[]>(
+  values: T,
+  params?: string | core.$YatspEnumParams
+): YatspMiniEnum<util.ToEnum<T[number]>>;
+function _enum<T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspMiniEnum<T>;
+// @__NO_SIDE_EFFECTS__
+function _enum(values: any, params?: string | core.$YatspEnumParams) {
+  const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+
+  return new YatspMiniEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+export { _enum as enum };
+
+// @__NO_SIDE_EFFECTS__
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export function nativeEnum<T extends util.EnumLike>(
+  entries: T,
+  params?: string | core.$YatspEnumParams
+): YatspMiniEnum<T> {
+  return new YatspMiniEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params),
+  }) as any as YatspMiniEnum<T>;
+}
+
+// YatspMiniLiteral
+export interface YatspMiniLiteral<T extends util.Literal = util.Literal>
+  extends _YatspMiniType<core.$YatspLiteralInternals<T>> {
+  // _yatsp: core.$YatspLiteralInternals<T>;
+}
+export const YatspMiniLiteral: core.$constructor<YatspMiniLiteral> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniLiteral",
+  (inst, def) => {
+    core.$YatspLiteral.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+export function literal<const T extends ReadonlyArray<util.Literal>>(
+  value: T,
+  params?: string | core.$YatspLiteralParams
+): YatspMiniLiteral<T[number]>;
+export function literal<const T extends util.Literal>(
+  value: T,
+  params?: string | core.$YatspLiteralParams
+): YatspMiniLiteral<T>;
+// @__NO_SIDE_EFFECTS__
+export function literal(value: any, params: any) {
+  return new YatspMiniLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(params),
+  });
+}
+
+// YatspMiniFile
+export interface YatspMiniFile extends _YatspMiniType<core.$YatspFileInternals> {
+  // _yatsp: core.$YatspFileInternals;
+}
+export const YatspMiniFile: core.$constructor<YatspMiniFile> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniFile",
+  (inst, def) => {
+    core.$YatspFile.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function file(params?: string | core.$YatspFileParams): YatspMiniFile {
+  return core._file(YatspMiniFile, params) as any;
+}
+
+// YatspMiniTransform
+export interface YatspMiniTransform<O = unknown, I = unknown>
+  extends _YatspMiniType<core.$YatspTransformInternals<O, I>> {
+  // _yatsp: core.$YatspTransformInternals<O, I>;
+}
+export const YatspMiniTransform: core.$constructor<YatspMiniTransform> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniTransform",
+  (inst, def) => {
+    core.$YatspTransform.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function transform<I = unknown, O = I>(
+  fn: (input: I, ctx: core.ParsePayload) => O
+): YatspMiniTransform<Awaited<O>, I> {
+  return new YatspMiniTransform({
+    type: "transform",
+    transform: fn as any,
+  }) as any;
+}
+
+// YatspMiniOptional
+export interface YatspMiniOptional<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspOptionalInternals<T>>,
+    core.$YatspOptional<T> {
+  // _yatsp: core.$YatspOptionalInternals<T>;
+}
+export const YatspMiniOptional: core.$constructor<YatspMiniOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniOptional",
+  (inst, def) => {
+    core.$YatspOptional.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function optional<T extends SomeType>(innerType: T): YatspMiniOptional<T> {
+  return new YatspMiniOptional({
+    type: "optional",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniExactOptional
+export interface YatspMiniExactOptional<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspExactOptionalInternals<T>>,
+    core.$YatspExactOptional<T> {
+  // _yatsp: core.$YatspExactOptionalInternals<T>;
+}
+export const YatspMiniExactOptional: core.$constructor<YatspMiniExactOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniExactOptional",
+  (inst, def) => {
+    core.$YatspExactOptional.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function exactOptional<T extends SomeType>(innerType: T): YatspMiniExactOptional<T> {
+  return new YatspMiniExactOptional({
+    type: "optional",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniNullable
+export interface YatspMiniNullable<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspNullableInternals<T>> {
+  // _yatsp: core.$YatspNullableInternals<T>;
+}
+export const YatspMiniNullable: core.$constructor<YatspMiniNullable> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNullable",
+  (inst, def) => {
+    core.$YatspNullable.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function nullable<T extends SomeType>(innerType: T): YatspMiniNullable<T> {
+  return new YatspMiniNullable({
+    type: "nullable",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// nullish
+// @__NO_SIDE_EFFECTS__
+export function nullish<T extends SomeType>(innerType: T): YatspMiniOptional<YatspMiniNullable<T>> {
+  return optional(nullable(innerType));
+}
+
+// YatspMiniDefault
+export interface YatspMiniDefault<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspDefaultInternals<T>> {
+  // _yatsp: core.$YatspDefaultInternals<T>;
+}
+export const YatspMiniDefault: core.$constructor<YatspMiniDefault> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniDefault",
+  (inst, def) => {
+    core.$YatspDefault.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function _default<T extends SomeType>(
+  innerType: T,
+  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)
+): YatspMiniDefault<T> {
+  return new YatspMiniDefault({
+    type: "default",
+    innerType: innerType as any as core.$YatspType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
+    },
+  }) as any;
+}
+
+// YatspMiniPrefault
+export interface YatspMiniPrefault<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspPrefaultInternals<T>> {
+  // _yatsp: core.$YatspPrefaultInternals<T>;
+}
+export const YatspMiniPrefault: core.$constructor<YatspMiniPrefault> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniPrefault",
+  (inst, def) => {
+    core.$YatspPrefault.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+// @__NO_SIDE_EFFECTS__
+export function prefault<T extends SomeType>(
+  innerType: T,
+  defaultValue: core.input<T> | (() => core.input<T>)
+): YatspMiniPrefault<T> {
+  return new YatspMiniPrefault({
+    type: "prefault",
+    innerType: innerType as any as core.$YatspType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
+    },
+  }) as any;
+}
+
+// YatspMiniNonOptional
+export interface YatspMiniNonOptional<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspNonOptionalInternals<T>> {
+  // _yatsp: core.$YatspNonOptionalInternals<T>;
+}
+export const YatspMiniNonOptional: core.$constructor<YatspMiniNonOptional> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNonOptional",
+  (inst, def) => {
+    core.$YatspNonOptional.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function nonoptional<T extends SomeType>(
+  innerType: T,
+  params?: string | core.$YatspNonOptionalParams
+): YatspMiniNonOptional<T> {
+  return new YatspMiniNonOptional({
+    type: "nonoptional",
+    innerType: innerType as any as core.$YatspType,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniSuccess
+export interface YatspMiniSuccess<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspSuccessInternals<T>> {
+  // _yatsp: core.$YatspSuccessInternals<T>;
+}
+export const YatspMiniSuccess: core.$constructor<YatspMiniSuccess> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniSuccess",
+  (inst, def) => {
+    core.$YatspSuccess.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function success<T extends SomeType>(innerType: T): YatspMiniSuccess<T> {
+  return new YatspMiniSuccess({
+    type: "success",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniCatch
+export interface YatspMiniCatch<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspCatchInternals<T>> {
+  // _yatsp: core.$YatspCatchInternals<T>;
+}
+export const YatspMiniCatch: core.$constructor<YatspMiniCatch> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCatch",
+  (inst, def) => {
+    core.$YatspCatch.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+function _catch<T extends SomeType>(
+  innerType: T,
+  catchValue: core.output<T> | ((ctx: core.$YatspCatchCtx) => core.output<T>)
+): YatspMiniCatch<T> {
+  return new YatspMiniCatch({
+    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 };
+
+// YatspMiniNaN
+export interface YatspMiniNaN extends _YatspMiniType<core.$YatspNaNInternals> {
+  // _yatsp: core.$YatspNaNInternals;
+}
+export const YatspMiniNaN: core.$constructor<YatspMiniNaN> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniNaN",
+  (inst, def) => {
+    core.$YatspNaN.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function nan(params?: string | core.$YatspNaNParams): YatspMiniNaN {
+  return core._nan(YatspMiniNaN, params) as any;
+}
+
+// YatspMiniPipe
+export interface YatspMiniPipe<A extends SomeType = core.$YatspType, B extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspPipeInternals<A, B>> {
+  // _yatsp: core.$YatspPipeInternals<A, B>;
+}
+export const YatspMiniPipe: core.$constructor<YatspMiniPipe> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniPipe",
+  (inst, def) => {
+    core.$YatspPipe.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function pipe<
+  const A extends 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>>): YatspMiniPipe<A, B> {
+  return new YatspMiniPipe({
+    type: "pipe",
+    in: in_ as any as core.$YatspType,
+    out: out as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniCodec
+export interface YatspMiniCodec<A extends SomeType = core.$YatspType, B extends SomeType = core.$YatspType>
+  extends YatspMiniPipe<A, B>,
+    core.$YatspCodec<A, B> {
+  _yatsp: core.$YatspCodecInternals<A, B>;
+  def: core.$YatspCodecDef<A, B>;
+}
+export const YatspMiniCodec: core.$constructor<YatspMiniCodec> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCodec",
+  (inst, def) => {
+    YatspMiniPipe.init(inst, def);
+    core.$YatspCodec.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function codec<const A extends 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>>;
+  }
+): YatspMiniCodec<A, B> {
+  return new YatspMiniCodec({
+    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;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function invertCodec<A extends SomeType, B extends SomeType>(codec: YatspMiniCodec<A, B>): YatspMiniCodec<B, A> {
+  const def = codec._yatsp.def;
+  return new YatspMiniCodec({
+    type: "pipe",
+    in: def.out as any,
+    out: def.in as any,
+    transform: def.reverseTransform as any,
+    reverseTransform: def.transform as any,
+  }) as any;
+}
+
+// YatspMiniReadonly
+export interface YatspMiniReadonly<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspReadonlyInternals<T>> {
+  // _yatsp: core.$YatspReadonlyInternals<T>;
+}
+export const YatspMiniReadonly: core.$constructor<YatspMiniReadonly> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniReadonly",
+  (inst, def) => {
+    core.$YatspReadonly.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function readonly<T extends SomeType>(innerType: T): YatspMiniReadonly<T> {
+  return new YatspMiniReadonly({
+    type: "readonly",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniTemplateLiteral
+export interface YatspMiniTemplateLiteral<Template extends string = string>
+  extends _YatspMiniType<core.$YatspTemplateLiteralInternals<Template>> {
+  // _yatsp: core.$YatspTemplateLiteralInternals<Template>;
+}
+export const YatspMiniTemplateLiteral: core.$constructor<YatspMiniTemplateLiteral> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniTemplateLiteral",
+  (inst, def) => {
+    core.$YatspTemplateLiteral.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function templateLiteral<const Parts extends core.$YatspTemplateLiteralPart[]>(
+  parts: Parts,
+  params?: string | core.$YatspTemplateLiteralParams
+): YatspMiniTemplateLiteral<core.$PartsToTemplateLiteral<Parts>> {
+  return new YatspMiniTemplateLiteral({
+    type: "template_literal",
+    parts,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+// YatspMiniLazy
+export interface YatspMiniLazy<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspLazyInternals<T>> {
+  // _yatsp: core.$YatspLazyInternals<T>;
+}
+export const YatspMiniLazy: core.$constructor<YatspMiniLazy> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniLazy",
+  (inst, def) => {
+    core.$YatspLazy.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// export function lazy<T extends object>(getter: () => T): T {
+//   return util.createTransparentProxy<T>(getter);
+// }
+// @__NO_SIDE_EFFECTS__
+function _lazy<T extends SomeType>(getter: () => T): YatspMiniLazy<T> {
+  return new YatspMiniLazy({
+    type: "lazy",
+    getter: getter as any,
+  }) as any;
+}
+export { _lazy as lazy };
+
+// YatspMiniPromise
+export interface YatspMiniPromise<T extends SomeType = core.$YatspType>
+  extends _YatspMiniType<core.$YatspPromiseInternals<T>> {
+  // _yatsp: core.$YatspPromiseInternals<T>;
+}
+export const YatspMiniPromise: core.$constructor<YatspMiniPromise> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniPromise",
+  (inst, def) => {
+    core.$YatspPromise.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function promise<T extends SomeType>(innerType: T): YatspMiniPromise<T> {
+  return new YatspMiniPromise({
+    type: "promise",
+    innerType: innerType as any as core.$YatspType,
+  }) as any;
+}
+
+// YatspMiniCustom
+export interface YatspMiniCustom<O = unknown, I = unknown> extends _YatspMiniType<core.$YatspCustomInternals<O, I>> {
+  // _yatsp: core.$YatspCustomInternals<O, I>;
+}
+export const YatspMiniCustom: core.$constructor<YatspMiniCustom> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniCustom",
+  (inst, def) => {
+    core.$YatspCustom.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+// custom checks
+// @__NO_SIDE_EFFECTS__
+export function check<O = unknown>(
+  fn: core.CheckFn<O>,
+  params?: string | core.$YatspCustomParams
+): core.$YatspCheck<O> {
+  const ch = new core.$YatspCheck({
+    check: "custom",
+    ...util.normalizeParams(params),
+  });
+
+  ch._yatsp.check = fn;
+  return ch;
+}
+
+// YatspCustom custom schema
+// @__NO_SIDE_EFFECTS__
+export function custom<O = unknown, I = O>(
+  fn?: (data: O) => unknown,
+  _params?: string | core.$YatspCustomParams | undefined
+): YatspMiniCustom<O, I> {
+  return core._custom(YatspMiniCustom, fn ?? (() => true), _params) as any;
+}
+
+// refine
+// @__NO_SIDE_EFFECTS__
+export function refine<T>(
+  fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
+  _params: string | core.$YatspCustomParams = {}
+): core.$YatspCheck<T> {
+  return core._refine(YatspMiniCustom, fn, _params);
+}
+
+// superRefine
+// @__NO_SIDE_EFFECTS__
+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;
+
+// instanceof
+abstract class Class {
+  constructor(..._args: any[]) {}
+}
+// @__NO_SIDE_EFFECTS__
+function _instanceof<T extends typeof Class>(
+  cls: T,
+  params: core.$YatspCustomParams = {}
+): YatspMiniCustom<InstanceType<T>, InstanceType<T>> {
+  const inst = custom((data) => data instanceof cls, params);
+  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
+) => YatspMiniCodec<YatspMiniString, YatspMiniBoolean> = (...args) =>
+  core._stringbool(
+    {
+      Codec: YatspMiniCodec,
+      Boolean: YatspMiniBoolean,
+      String: YatspMiniString,
+    },
+    ...args
+  ) as any;
+
+// json
+
+// json
+export type _YatspMiniJSONSchema = YatspMiniUnion<
+  [
+    YatspMiniString,
+    YatspMiniNumber,
+    YatspMiniBoolean,
+    YatspMiniNull,
+    YatspMiniArray<YatspMiniJSONSchema>,
+    YatspMiniRecord<YatspMiniString<string>, YatspMiniJSONSchema>,
+  ]
+>;
+export type _YatspMiniJSONSchemaInternals = _YatspMiniJSONSchema["_yatsp"];
+
+export interface YatspMiniJSONSchemaInternals extends _YatspMiniJSONSchemaInternals {
+  output: util.JSONType;
+  input: util.JSONType;
+}
+export interface YatspMiniJSONSchema extends _YatspMiniJSONSchema {
+  _yatsp: YatspMiniJSONSchemaInternals;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function json(): YatspMiniJSONSchema {
+  const jsonSchema: any = _lazy(() => {
+    return union([string(), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);
+  });
+  return jsonSchema;
+}
+
+// YatspMiniFunction
+export interface YatspMiniFunction<
+  Args extends core.$YatspFunctionIn = core.$YatspFunctionIn,
+  Returns extends core.$YatspFunctionOut = core.$YatspFunctionOut,
+> extends _YatspMiniType<core.$YatspFunctionInternals<Args, Returns>>,
+    core.$YatspFunction<Args, Returns> {
+  _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
+  ): YatspMiniFunction<YatspMiniTuple<Items, Rest>, Returns>;
+  input<NewArgs extends core.$YatspFunctionIn>(args: NewArgs): YatspMiniFunction<NewArgs, Returns>;
+  input(...args: any[]): YatspMiniFunction<any, Returns>;
+
+  output<NewReturns extends core.$YatspFunctionOut>(output: NewReturns): YatspMiniFunction<Args, NewReturns>;
+}
+
+export const YatspMiniFunction: core.$constructor<YatspMiniFunction> = /*@__PURE__*/ core.$constructor(
+  "YatspMiniFunction",
+  (inst, def) => {
+    core.$YatspFunction.init(inst, def);
+    YatspMiniType.init(inst, def);
+  }
+);
+
+export function _function(): YatspMiniFunction;
+export function _function<const In extends Array<SomeType> = Array<SomeType>>(params: {
+  input: In;
+}): YatspMiniFunction<YatspMiniTuple<In, null>, core.$YatspFunctionOut>;
+export function _function<
+  const In extends Array<SomeType> = Array<SomeType>,
+  const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut,
+>(params: {
+  input: In;
+  output: Out;
+}): YatspMiniFunction<YatspMiniTuple<In, null>, Out>;
+export function _function<const In extends core.$YatspFunctionIn = core.$YatspFunctionIn>(params: {
+  input: In;
+}): YatspMiniFunction<In, core.$YatspFunctionOut>;
+export function _function<const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params: {
+  output: Out;
+}): YatspMiniFunction<core.$YatspFunctionIn, Out>;
+export function _function<
+  In extends core.$YatspFunctionIn = core.$YatspFunctionIn,
+  Out extends core.$YatspFunctionOut = core.$YatspFunctionOut,
+>(params?: { input: In; output: Out }): YatspMiniFunction<In, Out>;
+// @__NO_SIDE_EFFECTS__
+export function _function(params?: {
+  output?: core.$YatspFunctionOut;
+  input?: core.$YatspFunctionArgs | Array<SomeType>;
+}): YatspMiniFunction {
+  return new YatspMiniFunction({
+    type: "function",
+    input: Array.isArray(params?.input) ? tuple(params?.input as any) : (params?.input ?? array(unknown())),
+    output: params?.output ?? unknown(),
+  });
+}
+
+export { _function as function };