@willaimg/yatsp 4.3.6

package/v4/core/schemas.d.cts

@@ -0,0 +1,1273 @@
+import * as checks from "./checks.cjs";
+import type { $YatspNumberFormats } from "./checks.cjs";
+import type { $YatspBigIntFormats } from "./checks.cjs";
+import * as core from "./core.cjs";
+import type * as errors from "./errors.cjs";
+import type * as JSONSchema from "./json-schema.cjs";
+import type { StandardSchemaV1 } from "./standard-schema.cjs";
+import type { ProcessParams, ToJSONSchemaContext } from "./to-json-schema.cjs";
+import * as util from "./util.cjs";
+import { version } from "./versions.cjs";
+export interface ParseContext<T extends errors.$YatspIssueBase = never> {
+    /** Customize error messages. */
+    readonly error?: errors.$YatspErrorMap<T>;
+    /** Include the `input` field in issue objects. Default `false`. */
+    readonly reportInput?: boolean;
+    /** Skip eval-based fast path. Default `false`. */
+    readonly jitless?: boolean;
+}
+/** @internal */
+export interface ParseContextInternal<T extends errors.$YatspIssueBase = never> extends ParseContext<T> {
+    readonly async?: boolean | undefined;
+    readonly direction?: "forward" | "backward";
+    readonly skipChecks?: boolean;
+    /** Set only by `validate`/`validateAsync`. A container may stop before its next child, never inside one, so a map entry and a tuple's fixed items parse whole. */
+    readonly abortEarly?: boolean;
+}
+/** Gives a container cycle support: `attach` wraps its parse, and `alloc` registers the object it builds into before any child is parsed so a reference back to the same input resolves to it. */
+export interface $YatspMemoizer {
+    attach(inst: $YatspType): void;
+    guard(inst: $YatspType): void;
+    alloc<T extends object>(inst: $YatspType, payload: ParsePayload, empty: T, ctx: ParseContextInternal): T;
+}
+export interface ParsePayload<T = unknown> {
+    value: T;
+    issues: errors.$YatspRawIssue[];
+    /** A way to mark a whole payload as aborted. Used in codecs/pipes. */
+    aborted?: boolean;
+    /** @internal Set when the value came from a repeat visit to a node still being
+     * parsed. Its checks run on the node itself, against the finished value. */
+    memo?: boolean | undefined;
+}
+export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
+export interface $YatspTypeDef {
+    type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
+    error?: errors.$YatspErrorMap<never> | undefined;
+    checks?: checks.$YatspCheck<never>[];
+}
+export interface _$YatspTypeInternals {
+    /** The `@yatsp/core` version of this schema */
+    version: typeof version;
+    /** Schema definition. */
+    def: $YatspTypeDef;
+    /** @internal Randomly generated ID for this schema. */
+    /** @internal List of deferred initializers. */
+    deferred: util.AnyFunc[] | undefined;
+    /** @internal Parses input and runs all checks (refinements). */
+    run(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;
+    /** @internal Parses input, doesn't run checks. */
+    parse(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;
+    /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+    traits: Set<string>;
+    /** @internal Indicates that a schema output type should be considered optional inside objects.
+     * @default Required
+     */
+    /** @internal Three rungs, each strictly stronger than the last:
+     *   undefined    — required; the container may not omit this slot
+     *   "optional"   — the container may omit it; nothing is supplied in its place
+     *   "defaulted"  — the container may omit it AND this schema substitutes a value
+     * Consumers asking "may the slot be absent?" test `!== undefined`.
+     * $YatspOptional asks the stronger question and tests `=== "defaulted"`. */
+    optin?: "optional" | "defaulted" | undefined;
+    /** @internal */
+    optout?: "optional" | undefined;
+    /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+     *
+     * Defined on: enum, const, literal, null, undefined
+     * Passthrough: optional, nullable, branded, default, catch, pipe
+     * Todo: unions?
+     */
+    values?: util.PrimitiveSet | undefined;
+    /** Default value bubbled up from  */
+    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+    propValues?: util.PropValues | undefined;
+    /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+    pattern: RegExp | undefined;
+    /** @internal The constructor function of this schema. */
+    constr: new (def: any) => $YatspType;
+    /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+    bag: Record<string, unknown>;
+    /** @internal The set of issues this schema might throw during type checking. */
+    isst: errors.$YatspIssueBase;
+    /** @internal Subject to change, not a public API. */
+    processJSONSchema?: ((ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void) | undefined;
+    /** An optional method used to override `toJSONSchema` logic. */
+    toJSONSchema?: () => unknown;
+    /** @internal The parent of this schema. Only set during certain clone operations. */
+    parent?: $YatspType | undefined;
+}
+/** @internal */
+export interface $YatspTypeInternals<out O = unknown, out I = unknown> extends _$YatspTypeInternals {
+    /** @internal The inferred output type */
+    output: O;
+    /** @internal The inferred input type */
+    input: I;
+}
+export type $YatspStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
+export type SomeType = {
+    _yatsp: _$YatspTypeInternals;
+};
+export interface $YatspType<O = unknown, I = unknown, Internals extends $YatspTypeInternals<O, I> = $YatspTypeInternals<O, I>> {
+    _yatsp: Internals;
+    "~standard": $YatspStandardSchema<this>;
+}
+export interface _$YatspType<T extends $YatspTypeInternals = $YatspTypeInternals> extends $YatspType<T["output"], T["input"], T> {
+}
+export declare const $YatspType: core.$constructor<$YatspType>;
+export declare function standardProps(inst: $YatspType): StandardSchemaV1.Props<any, any>;
+export { clone } from "./util.cjs";
+export interface $YatspStringDef extends $YatspTypeDef {
+    type: "string";
+    coerce?: boolean;
+    checks?: checks.$YatspCheck<string>[];
+}
+export interface $YatspStringInternals<Input> extends $YatspTypeInternals<string, Input> {
+    def: $YatspStringDef;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    isst: errors.$YatspIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        patterns: Set<RegExp>;
+        format: string;
+        contentEncoding: string;
+        /** the pattern admits strings its `format` keyword forbids, so `toJSONSchema` must not emit it */
+        laxFormat: boolean;
+    }>;
+}
+export interface $YatspString<Input = unknown> extends _$YatspType<$YatspStringInternals<Input>> {
+}
+export declare const $YatspString: core.$constructor<$YatspString>;
+export interface $YatspStringFormatDef<Format extends string = string> extends $YatspStringDef, checks.$YatspCheckStringFormatDef<Format> {
+}
+export interface $YatspStringFormatInternals<Format extends string = string> extends $YatspStringInternals<string>, checks.$YatspCheckStringFormatInternals {
+    def: $YatspStringFormatDef<Format>;
+}
+export interface $YatspStringFormat<Format extends string = string> extends $YatspType {
+    _yatsp: $YatspStringFormatInternals<Format>;
+}
+export declare const $YatspStringFormat: core.$constructor<$YatspStringFormat>;
+export interface $YatspGUIDDef extends $YatspStringFormatDef<"guid"> {
+}
+export interface $YatspGUIDInternals extends $YatspStringFormatInternals<"guid"> {
+}
+export interface $YatspGUID extends $YatspType {
+    _yatsp: $YatspGUIDInternals;
+}
+export declare const $YatspGUID: core.$constructor<$YatspGUID>;
+export interface $YatspUUIDDef extends $YatspStringFormatDef<"uuid"> {
+    version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+export interface $YatspUUIDInternals extends $YatspStringFormatInternals<"uuid"> {
+    def: $YatspUUIDDef;
+}
+export interface $YatspUUID extends $YatspType {
+    _yatsp: $YatspUUIDInternals;
+}
+export declare const $YatspUUID: core.$constructor<$YatspUUID>;
+export interface $YatspEmailDef extends $YatspStringFormatDef<"email"> {
+}
+export interface $YatspEmailInternals extends $YatspStringFormatInternals<"email"> {
+}
+export interface $YatspEmail extends $YatspType {
+    _yatsp: $YatspEmailInternals;
+}
+export declare const $YatspEmail: core.$constructor<$YatspEmail>;
+export interface $YatspURLDef extends $YatspStringFormatDef<"url"> {
+    hostname?: RegExp | undefined;
+    protocol?: RegExp | undefined;
+    normalize?: boolean | undefined;
+}
+export interface $YatspURLInternals extends $YatspStringFormatInternals<"url"> {
+    def: $YatspURLDef;
+}
+export interface $YatspURL extends $YatspType {
+    _yatsp: $YatspURLInternals;
+}
+/** The `://` guard rejected the input before the URL constructor saw it. */
+export declare const URL_BAD_FORMAT = 1;
+/** The URL parser rejected the input. */
+export declare const URL_UNPARSEABLE = 2;
+export declare function canParseURL(input: string): boolean;
+export declare function validateURL(trimmed: string, def: Pick<$YatspURLDef, "protocol" | "hostname" | "normalize">): URL | true | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** Parses a URL while preserving the non-normalizing HTTP guard. */
+export declare function parseURLObject(trimmed: string, def: Pick<$YatspURLDef, "protocol" | "normalize">): URL | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
+export declare function stripTabAndNewline(value: string): string;
+export declare function urlHostnameOk(url: URL, hostname: RegExp): boolean;
+export declare function urlProtocolOk(url: URL, protocol: RegExp): boolean;
+export declare const $YatspURL: core.$constructor<$YatspURL>;
+export interface $YatspEmojiDef extends $YatspStringFormatDef<"emoji"> {
+}
+export interface $YatspEmojiInternals extends $YatspStringFormatInternals<"emoji"> {
+}
+export interface $YatspEmoji extends $YatspType {
+    _yatsp: $YatspEmojiInternals;
+}
+export declare const $YatspEmoji: core.$constructor<$YatspEmoji>;
+export interface $YatspNanoIDDef extends $YatspStringFormatDef<"nanoid"> {
+    length?: number | undefined;
+}
+export interface $YatspNanoIDInternals extends $YatspStringFormatInternals<"nanoid"> {
+    def: $YatspNanoIDDef;
+}
+export interface $YatspNanoID extends $YatspType {
+    _yatsp: $YatspNanoIDInternals;
+}
+export declare const $YatspNanoID: core.$constructor<$YatspNanoID>;
+/**
+ * @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 $YatspCUIDDef extends $YatspStringFormatDef<"cuid"> {
+}
+/**
+ * @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 $YatspCUIDInternals extends $YatspStringFormatInternals<"cuid"> {
+}
+/**
+ * @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 $YatspType {
+    _yatsp: $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 declare const $YatspCUID: core.$constructor<$YatspCUID>;
+export interface $YatspCUID2Def extends $YatspStringFormatDef<"cuid2"> {
+}
+export interface $YatspCUID2Internals extends $YatspStringFormatInternals<"cuid2"> {
+}
+export interface $YatspCUID2 extends $YatspType {
+    _yatsp: $YatspCUID2Internals;
+}
+export declare const $YatspCUID2: core.$constructor<$YatspCUID2>;
+export interface $YatspULIDDef extends $YatspStringFormatDef<"ulid"> {
+}
+export interface $YatspULIDInternals extends $YatspStringFormatInternals<"ulid"> {
+}
+export interface $YatspULID extends $YatspType {
+    _yatsp: $YatspULIDInternals;
+}
+export declare const $YatspULID: core.$constructor<$YatspULID>;
+export interface $YatspXIDDef extends $YatspStringFormatDef<"xid"> {
+}
+export interface $YatspXIDInternals extends $YatspStringFormatInternals<"xid"> {
+}
+export interface $YatspXID extends $YatspType {
+    _yatsp: $YatspXIDInternals;
+}
+export declare const $YatspXID: core.$constructor<$YatspXID>;
+export interface $YatspKSUIDDef extends $YatspStringFormatDef<"ksuid"> {
+}
+export interface $YatspKSUIDInternals extends $YatspStringFormatInternals<"ksuid"> {
+}
+export interface $YatspKSUID extends $YatspType {
+    _yatsp: $YatspKSUIDInternals;
+}
+export declare const $YatspKSUID: core.$constructor<$YatspKSUID>;
+export interface $YatspISODateTimeDef extends $YatspStringFormatDef<"datetime"> {
+    precision: number | null;
+    offset: boolean;
+    local: boolean;
+}
+export interface $YatspISODateTimeInternals extends $YatspStringFormatInternals {
+    def: $YatspISODateTimeDef;
+}
+export interface $YatspISODateTime extends $YatspType {
+    _yatsp: $YatspISODateTimeInternals;
+}
+export declare const $YatspISODateTime: core.$constructor<$YatspISODateTime>;
+export interface $YatspISODateDef extends $YatspStringFormatDef<"date"> {
+}
+export interface $YatspISODateInternals extends $YatspStringFormatInternals<"date"> {
+}
+export interface $YatspISODate extends $YatspType {
+    _yatsp: $YatspISODateInternals;
+}
+export declare const $YatspISODate: core.$constructor<$YatspISODate>;
+export interface $YatspISOTimeDef extends $YatspStringFormatDef<"time"> {
+    precision?: number | null;
+}
+export interface $YatspISOTimeInternals extends $YatspStringFormatInternals<"time"> {
+    def: $YatspISOTimeDef;
+}
+export interface $YatspISOTime extends $YatspType {
+    _yatsp: $YatspISOTimeInternals;
+}
+export declare const $YatspISOTime: core.$constructor<$YatspISOTime>;
+export interface $YatspISODurationDef extends $YatspStringFormatDef<"duration"> {
+}
+export interface $YatspISODurationInternals extends $YatspStringFormatInternals<"duration"> {
+}
+export interface $YatspISODuration extends $YatspType {
+    _yatsp: $YatspISODurationInternals;
+}
+export declare const $YatspISODuration: core.$constructor<$YatspISODuration>;
+export interface $YatspIPv4Def extends $YatspStringFormatDef<"ipv4"> {
+    version?: "v4";
+}
+export interface $YatspIPv4Internals extends $YatspStringFormatInternals<"ipv4"> {
+    def: $YatspIPv4Def;
+}
+export interface $YatspIPv4 extends $YatspType {
+    _yatsp: $YatspIPv4Internals;
+}
+export declare const $YatspIPv4: core.$constructor<$YatspIPv4>;
+export interface $YatspIPv6Def extends $YatspStringFormatDef<"ipv6"> {
+    version?: "v6";
+}
+export interface $YatspIPv6Internals extends $YatspStringFormatInternals<"ipv6"> {
+    def: $YatspIPv6Def;
+}
+export interface $YatspIPv6 extends $YatspType {
+    _yatsp: $YatspIPv6Internals;
+}
+export declare function isValidIPv6(value: string): boolean;
+export declare const $YatspIPv6: core.$constructor<$YatspIPv6>;
+export interface $YatspMACDef extends $YatspStringFormatDef<"mac"> {
+    delimiter?: string;
+}
+export interface $YatspMACInternals extends $YatspStringFormatInternals<"mac"> {
+    def: $YatspMACDef;
+}
+export interface $YatspMAC extends $YatspType {
+    _yatsp: $YatspMACInternals;
+}
+export declare const $YatspMAC: core.$constructor<$YatspMAC>;
+export interface $YatspCIDRv4Def extends $YatspStringFormatDef<"cidrv4"> {
+    version?: "v4";
+}
+export interface $YatspCIDRv4Internals extends $YatspStringFormatInternals<"cidrv4"> {
+    def: $YatspCIDRv4Def;
+}
+export interface $YatspCIDRv4 extends $YatspType {
+    _yatsp: $YatspCIDRv4Internals;
+}
+export declare const $YatspCIDRv4: core.$constructor<$YatspCIDRv4>;
+export interface $YatspCIDRv6Def extends $YatspStringFormatDef<"cidrv6"> {
+    version?: "v6";
+}
+export interface $YatspCIDRv6Internals extends $YatspStringFormatInternals<"cidrv6"> {
+    def: $YatspCIDRv6Def;
+}
+export interface $YatspCIDRv6 extends $YatspType {
+    _yatsp: $YatspCIDRv6Internals;
+}
+export declare function isValidCIDRv6(value: string): boolean;
+export declare const $YatspCIDRv6: core.$constructor<$YatspCIDRv6>;
+export declare function isValidBase64(data: string): boolean;
+export interface $YatspBase64Def extends $YatspStringFormatDef<"base64"> {
+}
+export interface $YatspBase64Internals extends $YatspStringFormatInternals<"base64"> {
+}
+export interface $YatspBase64 extends $YatspType {
+    _yatsp: $YatspBase64Internals;
+}
+export declare const base64Charset: RegExp;
+export declare const $YatspBase64: core.$constructor<$YatspBase64>;
+export declare const base64urlCharset: RegExp;
+export declare function isValidBase64URL(data: string): boolean;
+export interface $YatspBase64URLDef extends $YatspStringFormatDef<"base64url"> {
+}
+export interface $YatspBase64URLInternals extends $YatspStringFormatInternals<"base64url"> {
+}
+export interface $YatspBase64URL extends $YatspType {
+    _yatsp: $YatspBase64URLInternals;
+}
+export declare const $YatspBase64URL: core.$constructor<$YatspBase64URL>;
+export interface $YatspE164Def extends $YatspStringFormatDef<"e164"> {
+}
+export interface $YatspE164Internals extends $YatspStringFormatInternals<"e164"> {
+}
+export interface $YatspE164 extends $YatspType {
+    _yatsp: $YatspE164Internals;
+}
+export declare const $YatspE164: core.$constructor<$YatspE164>;
+export declare function isValidCreditCard(input: string): boolean;
+export interface $YatspCreditCardDef extends $YatspStringFormatDef<"credit_card"> {
+}
+export interface $YatspCreditCardInternals extends $YatspStringFormatInternals<"credit_card"> {
+    def: $YatspCreditCardDef;
+}
+export interface $YatspCreditCard extends $YatspType {
+    _yatsp: $YatspCreditCardInternals;
+}
+export declare const $YatspCreditCard: core.$constructor<$YatspCreditCard>;
+export declare function isValidIBAN(input: string): boolean;
+export interface $YatspIBANDef extends $YatspStringFormatDef<"iban"> {
+}
+export interface $YatspIBANInternals extends $YatspStringFormatInternals<"iban"> {
+    def: $YatspIBANDef;
+}
+export interface $YatspIBAN extends $YatspType {
+    _yatsp: $YatspIBANInternals;
+}
+export declare const $YatspIBAN: core.$constructor<$YatspIBAN>;
+export declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;
+export interface $YatspJWTDef extends $YatspStringFormatDef<"jwt"> {
+    alg?: util.JWTAlgorithm | undefined;
+}
+export interface $YatspJWTInternals extends $YatspStringFormatInternals<"jwt"> {
+    def: $YatspJWTDef;
+}
+export interface $YatspJWT extends $YatspType {
+    _yatsp: $YatspJWTInternals;
+}
+export declare const $YatspJWT: core.$constructor<$YatspJWT>;
+export interface $YatspCustomStringFormatDef<Format extends string = string> extends $YatspStringFormatDef<Format> {
+    fn: (val: string) => unknown;
+}
+export interface $YatspCustomStringFormatInternals<Format extends string = string> extends $YatspStringFormatInternals<Format> {
+    def: $YatspCustomStringFormatDef<Format>;
+}
+export interface $YatspCustomStringFormat<Format extends string = string> extends $YatspStringFormat<Format> {
+    _yatsp: $YatspCustomStringFormatInternals<Format>;
+}
+export declare const $YatspCustomStringFormat: core.$constructor<$YatspCustomStringFormat>;
+export interface $YatspNumberDef extends $YatspTypeDef {
+    type: "number";
+    coerce?: boolean;
+}
+export interface $YatspNumberInternals<Input = unknown> extends $YatspTypeInternals<number, Input> {
+    def: $YatspNumberDef;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    isst: errors.$YatspIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        exclusiveMinimum: number;
+        exclusiveMaximum: number;
+        format: string;
+        pattern: RegExp;
+    }>;
+}
+export interface $YatspNumber<Input = unknown> extends $YatspType {
+    _yatsp: $YatspNumberInternals<Input>;
+}
+export declare const $YatspNumber: core.$constructor<$YatspNumber>;
+export interface $YatspNumberFormatDef<Format extends $YatspNumberFormats = $YatspNumberFormats> extends $YatspNumberDef, checks.$YatspCheckNumberFormatDef<Format> {
+}
+export interface $YatspNumberFormatInternals<Format extends $YatspNumberFormats = $YatspNumberFormats> extends $YatspNumberInternals<number>, checks.$YatspCheckNumberFormatInternals<Format> {
+    def: $YatspNumberFormatDef<Format>;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspNumberFormat<Format extends $YatspNumberFormats = $YatspNumberFormats> extends $YatspType {
+    _yatsp: $YatspNumberFormatInternals<Format>;
+}
+export declare const $YatspNumberFormat: core.$constructor<$YatspNumberFormat>;
+export interface $YatspBooleanDef extends $YatspTypeDef {
+    type: "boolean";
+    coerce?: boolean;
+    checks?: checks.$YatspCheck<boolean>[];
+}
+export interface $YatspBooleanInternals<T = unknown> extends $YatspTypeInternals<boolean, T> {
+    pattern: RegExp;
+    def: $YatspBooleanDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspBoolean<T = unknown> extends $YatspType {
+    _yatsp: $YatspBooleanInternals<T>;
+}
+export declare const $YatspBoolean: core.$constructor<$YatspBoolean>;
+export interface $YatspBigIntDef extends $YatspTypeDef {
+    type: "bigint";
+    coerce?: boolean;
+}
+export interface $YatspBigIntInternals<T = unknown> extends $YatspTypeInternals<bigint, T> {
+    pattern: RegExp;
+    /** @internal Internal API, use with caution */
+    def: $YatspBigIntDef;
+    isst: errors.$YatspIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: bigint;
+        maximum: bigint;
+        format: string;
+    }>;
+}
+export interface $YatspBigInt<T = unknown> extends $YatspType {
+    _yatsp: $YatspBigIntInternals<T>;
+}
+export declare const $YatspBigInt: core.$constructor<$YatspBigInt>;
+export interface $YatspBigIntFormatDef<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends $YatspBigIntDef, checks.$YatspCheckBigIntFormatDef<Format> {
+    check: "bigint_format";
+}
+export interface $YatspBigIntFormatInternals<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends $YatspBigIntInternals<bigint>, checks.$YatspCheckBigIntFormatInternals<Format> {
+    def: $YatspBigIntFormatDef<Format>;
+}
+export interface $YatspBigIntFormat<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends $YatspType {
+    _yatsp: $YatspBigIntFormatInternals<Format>;
+}
+export declare const $YatspBigIntFormat: core.$constructor<$YatspBigIntFormat>;
+export interface $YatspSymbolDef extends $YatspTypeDef {
+    type: "symbol";
+}
+export interface $YatspSymbolInternals extends $YatspTypeInternals<symbol, symbol> {
+    def: $YatspSymbolDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspSymbol extends $YatspType {
+    _yatsp: $YatspSymbolInternals;
+}
+export declare const $YatspSymbol: core.$constructor<$YatspSymbol>;
+export interface $YatspUndefinedDef extends $YatspTypeDef {
+    type: "undefined";
+}
+export interface $YatspUndefinedInternals extends $YatspTypeInternals<undefined, undefined> {
+    pattern: RegExp;
+    def: $YatspUndefinedDef;
+    values: util.PrimitiveSet;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspUndefined extends $YatspType {
+    _yatsp: $YatspUndefinedInternals;
+}
+export declare const $YatspUndefined: core.$constructor<$YatspUndefined>;
+export interface $YatspNullDef extends $YatspTypeDef {
+    type: "null";
+}
+export interface $YatspNullInternals extends $YatspTypeInternals<null, null> {
+    pattern: RegExp;
+    def: $YatspNullDef;
+    values: util.PrimitiveSet;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspNull extends $YatspType {
+    _yatsp: $YatspNullInternals;
+}
+export declare const $YatspNull: core.$constructor<$YatspNull>;
+export interface $YatspAnyDef extends $YatspTypeDef {
+    type: "any";
+}
+export interface $YatspAnyInternals extends $YatspTypeInternals<any, any> {
+    def: $YatspAnyDef;
+    isst: never;
+}
+export interface $YatspAny extends $YatspType {
+    _yatsp: $YatspAnyInternals;
+}
+export declare const $YatspAny: core.$constructor<$YatspAny>;
+export interface $YatspUnknownDef extends $YatspTypeDef {
+    type: "unknown";
+}
+export interface $YatspUnknownInternals extends $YatspTypeInternals<unknown, unknown> {
+    def: $YatspUnknownDef;
+    isst: never;
+}
+export interface $YatspUnknown extends $YatspType {
+    _yatsp: $YatspUnknownInternals;
+}
+export declare const $YatspUnknown: core.$constructor<$YatspUnknown>;
+export interface $YatspNeverDef extends $YatspTypeDef {
+    type: "never";
+}
+export interface $YatspNeverInternals extends $YatspTypeInternals<never, never> {
+    def: $YatspNeverDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspNever extends $YatspType {
+    _yatsp: $YatspNeverInternals;
+}
+export declare const $YatspNever: core.$constructor<$YatspNever>;
+export interface $YatspVoidDef extends $YatspTypeDef {
+    type: "void";
+}
+export interface $YatspVoidInternals extends $YatspTypeInternals<void, void> {
+    def: $YatspVoidDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspVoid extends $YatspType {
+    _yatsp: $YatspVoidInternals;
+}
+export declare const $YatspVoid: core.$constructor<$YatspVoid>;
+export interface $YatspDateDef extends $YatspTypeDef {
+    type: "date";
+    coerce?: boolean;
+}
+export interface $YatspDateInternals<T = unknown> extends $YatspTypeInternals<Date, T> {
+    def: $YatspDateDef;
+    isst: errors.$YatspIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: Date;
+        maximum: Date;
+        format: string;
+    }>;
+}
+export interface $YatspDate<T = unknown> extends $YatspType {
+    _yatsp: $YatspDateInternals<T>;
+}
+export declare const $YatspDate: core.$constructor<$YatspDate>;
+export interface $YatspArrayDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "array";
+    element: T;
+}
+export interface $YatspArrayInternals<T extends SomeType = $YatspType> extends _$YatspTypeInternals {
+    def: $YatspArrayDef<T>;
+    isst: errors.$YatspIssueInvalidType;
+    output: core.output<T>[];
+    input: core.input<T>[];
+}
+export interface $YatspArray<T extends SomeType = $YatspType> extends $YatspType<any, any, $YatspArrayInternals<T>> {
+}
+export declare const $YatspArray: core.$constructor<$YatspArray>;
+type OptionalOutSchema = {
+    _yatsp: {
+        optout: "optional";
+    };
+};
+type OptionalInSchema = {
+    _yatsp: {
+        optin: "optional" | "defaulted";
+    };
+};
+export type $InferObjectOutput<T extends $YatspLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : {
+    [k in string]: core.output<T[keyof T]>;
+} : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_yatsp"]["output"];
+} & {
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_yatsp"]["output"];
+} & Extra>;
+export type $InferObjectInput<T extends $YatspLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : {
+    [k in string]: core.input<T[keyof T]>;
+} : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_yatsp"]["input"];
+} & {
+    -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_yatsp"]["input"];
+} & Extra>;
+export type $YatspObjectConfig = {
+    out: Record<string, unknown>;
+    in: Record<string, unknown>;
+};
+export type $loose = {
+    out: Record<string, unknown>;
+    in: Record<string, unknown>;
+};
+export type $strict = {
+    out: {};
+    in: {};
+};
+export type $strip = {
+    out: {};
+    in: {};
+};
+export type $catchall<T extends SomeType> = {
+    out: {
+        [k: string]: core.output<T>;
+    };
+    in: {
+        [k: string]: core.input<T>;
+    };
+};
+export type $YatspShape = Readonly<{
+    [k: string]: $YatspType;
+}>;
+export interface $YatspObjectDef<Shape extends $YatspShape = $YatspShape> extends $YatspTypeDef {
+    type: "object";
+    shape: Shape;
+    catchall?: $YatspType | undefined;
+}
+export interface $YatspObjectInternals<
+/** @ts-ignore Cast variance */
+out Shape extends $YatspShape = $YatspShape, out Config extends $YatspObjectConfig = $YatspObjectConfig> extends _$YatspTypeInternals {
+    def: $YatspObjectDef<Shape>;
+    config: Config;
+    isst: errors.$YatspIssueInvalidType | errors.$YatspIssueUnrecognizedKeys;
+    propValues: util.PropValues;
+    output: $InferObjectOutput<Shape, Config["out"]>;
+    input: $InferObjectInput<Shape, Config["in"]>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+}
+export type $YatspLooseShape = Record<string, any>;
+export interface $YatspObject<
+/** @ts-ignore Cast variance */
+out Shape extends Readonly<$YatspShape> = Readonly<$YatspShape>, out Params extends $YatspObjectConfig = $YatspObjectConfig> extends $YatspType<any, any, $YatspObjectInternals<Shape, Params>> {
+}
+export declare const $YatspObject: core.$constructor<$YatspObject>;
+export declare const $YatspObjectJIT: core.$constructor<$YatspObject>;
+export type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;
+export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;
+export interface $YatspUnionDef<Options extends readonly SomeType[] = readonly $YatspType[]> extends $YatspTypeDef {
+    type: "union";
+    options: Options;
+    inclusive?: boolean;
+}
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+export interface $YatspUnionInternals<T extends readonly SomeType[] = readonly $YatspType[]> extends _$YatspTypeInternals {
+    def: $YatspUnionDef<T>;
+    isst: errors.$YatspIssueInvalidUnion;
+    pattern: T[number]["_yatsp"]["pattern"];
+    values: T[number]["_yatsp"]["values"];
+    output: $InferUnionOutput<T[number]>;
+    input: $InferUnionInput<T[number]>;
+    optin: IsOptionalIn<T[number]> extends false ? "optional" | "defaulted" | undefined : "optional" | "defaulted";
+    optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+export interface $YatspUnion<T extends readonly SomeType[] = readonly $YatspType[]> extends $YatspType<any, any, $YatspUnionInternals<T>> {
+    _yatsp: $YatspUnionInternals<T>;
+}
+export declare const $YatspUnion: core.$constructor<$YatspUnion>;
+export interface $YatspXorInternals<T extends readonly SomeType[] = readonly $YatspType[]> extends $YatspUnionInternals<T> {
+}
+export interface $YatspXor<T extends readonly SomeType[] = readonly $YatspType[]> extends $YatspType<any, any, $YatspXorInternals<T>> {
+    _yatsp: $YatspXorInternals<T>;
+}
+export declare const $YatspXor: core.$constructor<$YatspXor>;
+export interface $YatspDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $YatspType[], Disc extends string = string> extends $YatspUnionDef<Options> {
+    discriminator: Disc;
+    unionFallback?: boolean;
+}
+export interface $YatspDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $YatspType[], Disc extends string = string> extends $YatspUnionInternals<Options> {
+    def: $YatspDiscriminatedUnionDef<Options, Disc>;
+    propValues: util.PropValues;
+    bag: util.LoosePartial<{
+        optionsMap: Map<util.Primitive, $YatspType | null>;
+    }>;
+}
+/** The discriminator values a member of `Options` can declare. An omittable discriminator contributes `undefined`, matching what `propValues` claims for it. */
+export type $DiscriminatorValue<Options extends readonly SomeType[], Disc extends string> = {
+    [I in keyof Options]: Options[I] extends {
+        _yatsp: {
+            output: infer Out;
+        };
+    } ? Disc extends keyof Out ? Out[Disc] : never : never;
+}[number];
+/** The member of `Options` that declares `V`. */
+export type $DiscriminatedOption<Options extends readonly SomeType[], Disc extends string, V> = {
+    [I in keyof Options]: Options[I] extends {
+        _yatsp: {
+            output: infer Out;
+        };
+    } ? Disc extends keyof Out ? V extends Out[Disc] ? Options[I] : never : never : never;
+}[number];
+/** Returns the option whose discriminator claims `value`, or throws if ambiguous. */
+export declare function getDiscriminatedOption<Options extends readonly SomeType[], Disc extends string, const V extends $DiscriminatorValue<Options, Disc>>(union: $YatspDiscriminatedUnion<Options, Disc>, value: V): $DiscriminatedOption<Options, Disc, V>;
+export interface $YatspDiscriminatedUnion<Options extends readonly SomeType[] = readonly $YatspType[], Disc extends string = string> extends $YatspType {
+    _yatsp: $YatspDiscriminatedUnionInternals<Options, Disc>;
+}
+export declare const $YatspDiscriminatedUnion: core.$constructor<$YatspDiscriminatedUnion>;
+export interface $YatspIntersectionDef<Left extends SomeType = $YatspType, Right extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "intersection";
+    left: Left;
+    right: Right;
+}
+export interface $YatspIntersectionInternals<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends _$YatspTypeInternals {
+    def: $YatspIntersectionDef<A, B>;
+    isst: never;
+    optin: A["_yatsp"]["optin"] | B["_yatsp"]["optin"];
+    optout: A["_yatsp"]["optout"] | B["_yatsp"]["optout"];
+    output: core.output<A> & core.output<B>;
+    input: core.input<A> & core.input<B>;
+}
+export interface $YatspIntersection<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspIntersectionInternals<A, B>;
+}
+export declare const $YatspIntersection: core.$constructor<$YatspIntersection>;
+export declare function mergeValues(a: any, b: any): {
+    valid: true;
+    data: any;
+} | {
+    valid: false;
+    mergeErrorPath: (string | number)[];
+};
+export interface $YatspTupleDef<T extends util.TupleItems = readonly $YatspType[], Rest extends SomeType | null = $YatspType | null> extends $YatspTypeDef {
+    type: "tuple";
+    items: T;
+    rest: Rest;
+}
+export type $InferTupleInputType<T extends util.TupleItems, Rest extends SomeType | null> = [
+    ...TupleInputTypeWithOptionals<T>,
+    ...(Rest extends SomeType ? core.input<Rest>[] : [])
+];
+type TupleInputTypeNoOptionals<T extends util.TupleItems> = {
+    [k in keyof T]: core.input<T[k]>;
+};
+type TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
+    ...infer Prefix extends SomeType[],
+    infer Tail extends SomeType
+] ? Tail["_yatsp"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+export type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [
+    ...TupleOutputTypeWithOptionals<T>,
+    ...(Rest extends SomeType ? core.output<Rest>[] : [])
+];
+type TupleOutputTypeNoOptionals<T extends util.TupleItems> = {
+    [k in keyof T]: core.output<T[k]>;
+};
+type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
+    ...infer Prefix extends SomeType[],
+    infer Tail extends SomeType
+] ? Tail["_yatsp"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+export interface $YatspTupleInternals<T extends util.TupleItems = readonly $YatspType[], Rest extends SomeType | null = $YatspType | null> extends _$YatspTypeInternals {
+    def: $YatspTupleDef<T, Rest>;
+    isst: errors.$YatspIssueInvalidType | errors.$YatspIssueTooBig<unknown[]> | errors.$YatspIssueTooSmall<unknown[]>;
+    output: $InferTupleOutputType<T, Rest>;
+    input: $InferTupleInputType<T, Rest>;
+}
+export interface $YatspTuple<T extends util.TupleItems = readonly $YatspType[], Rest extends SomeType | null = $YatspType | null> extends $YatspType {
+    _yatsp: $YatspTupleInternals<T, Rest>;
+}
+export declare const $YatspTuple: core.$constructor<$YatspTuple>;
+export type $YatspRecordKey = $YatspType<string | number | symbol, unknown>;
+export interface $YatspRecordDef<Key extends $YatspRecordKey = $YatspRecordKey, Value extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "record";
+    keyType: Key;
+    valueType: Value;
+    /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+    mode?: "strict" | "loose";
+    partial?: boolean;
+}
+export type $InferYatspRecordOutput<Key extends $YatspRecordKey = $YatspRecordKey, Value extends SomeType = $YatspType> = Key extends $partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
+export type $InferYatspRecordInput<Key extends $YatspRecordKey = $YatspRecordKey, Value extends SomeType = $YatspType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : [
+    Value
+] extends [OptionalInSchema] ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
+export interface $YatspRecordInternals<Key extends $YatspRecordKey = $YatspRecordKey, Value extends SomeType = $YatspType> extends $YatspTypeInternals<$InferYatspRecordOutput<Key, Value>, $InferYatspRecordInput<Key, Value>> {
+    def: $YatspRecordDef<Key, Value>;
+    isst: errors.$YatspIssueInvalidType | errors.$YatspIssueInvalidKey<Record<PropertyKey, unknown>>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+}
+export type $partial = {
+    "~~partial": true;
+};
+export interface $YatspRecord<Key extends $YatspRecordKey = $YatspRecordKey, Value extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspRecordInternals<Key, Value>;
+}
+export declare const $YatspRecord: core.$constructor<$YatspRecord>;
+export interface $YatspMapDef<Key extends SomeType = $YatspType, Value extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "map";
+    keyType: Key;
+    valueType: Value;
+}
+export interface $YatspMapInternals<Key extends SomeType = $YatspType, Value extends SomeType = $YatspType> extends $YatspTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
+    def: $YatspMapDef<Key, Value>;
+    isst: errors.$YatspIssueInvalidType | errors.$YatspIssueInvalidKey | errors.$YatspIssueInvalidElement<unknown>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+}
+export interface $YatspMap<Key extends SomeType = $YatspType, Value extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspMapInternals<Key, Value>;
+}
+export declare const $YatspMap: core.$constructor<$YatspMap>;
+export interface $YatspSetDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "set";
+    valueType: T;
+}
+export interface $YatspSetInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
+    def: $YatspSetDef<T>;
+    isst: errors.$YatspIssueInvalidType;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+}
+export interface $YatspSet<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspSetInternals<T>;
+}
+export declare const $YatspSet: core.$constructor<$YatspSet>;
+export type $InferEnumOutput<T extends util.EnumLike> = T[keyof T] & {};
+export type $InferEnumInput<T extends util.EnumLike> = T[keyof T] & {};
+export interface $YatspEnumDef<T extends util.EnumLike = util.EnumLike> extends $YatspTypeDef {
+    type: "enum";
+    entries: T;
+}
+export interface $YatspEnumInternals<
+/** @ts-ignore Cast variance */
+out T extends util.EnumLike = util.EnumLike> extends $YatspTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+    def: $YatspEnumDef<T>;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    values: util.PrimitiveSet;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    isst: errors.$YatspIssueInvalidValue;
+}
+export interface $YatspEnum<T extends util.EnumLike = util.EnumLike> extends $YatspType {
+    _yatsp: $YatspEnumInternals<T>;
+}
+export declare const $YatspEnum: core.$constructor<$YatspEnum>;
+export interface $YatspLiteralDef<T extends util.Literal> extends $YatspTypeDef {
+    type: "literal";
+    values: T[];
+}
+export interface $YatspLiteralInternals<T extends util.Literal = util.Literal> extends $YatspTypeInternals<T, T> {
+    def: $YatspLiteralDef<T>;
+    values: Set<T>;
+    pattern: RegExp;
+    isst: errors.$YatspIssueInvalidValue;
+}
+export interface $YatspLiteral<T extends util.Literal = util.Literal> extends $YatspType {
+    _yatsp: $YatspLiteralInternals<T>;
+}
+export declare const $YatspLiteral: core.$constructor<$YatspLiteral>;
+type _File = typeof globalThis extends {
+    File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+export interface File extends _File {
+    readonly type: string;
+    readonly size: number;
+}
+export interface $YatspFileDef extends $YatspTypeDef {
+    type: "file";
+}
+export interface $YatspFileInternals extends $YatspTypeInternals<File, File> {
+    def: $YatspFileDef;
+    isst: errors.$YatspIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        mime: util.MimeTypes[];
+    }>;
+}
+export interface $YatspFile extends $YatspType {
+    _yatsp: $YatspFileInternals;
+}
+export declare const $YatspFile: core.$constructor<$YatspFile>;
+export interface $YatspTransformDef extends $YatspTypeDef {
+    type: "transform";
+    transform: (input: unknown, payload: ParsePayload<unknown>) => util.MaybeAsync<unknown>;
+}
+export interface $YatspTransformInternals<O = unknown, I = unknown> extends $YatspTypeInternals<O, I> {
+    def: $YatspTransformDef;
+    isst: never;
+}
+export interface $YatspTransform<O = unknown, I = unknown> extends $YatspType {
+    _yatsp: $YatspTransformInternals<O, I>;
+}
+export declare const $YatspTransform: core.$constructor<$YatspTransform>;
+export interface $YatspOptionalDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "optional";
+    innerType: T;
+}
+export interface $YatspOptionalInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
+    def: $YatspOptionalDef<T>;
+    optin: "optional" | "defaulted";
+    optout: "optional";
+    isst: never;
+    values: T["_yatsp"]["values"];
+    pattern: T["_yatsp"]["pattern"];
+}
+export interface $YatspOptional<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspOptionalInternals<T>;
+}
+export declare const $YatspOptional: core.$constructor<$YatspOptional>;
+export interface $YatspExactOptionalDef<T extends SomeType = $YatspType> extends $YatspOptionalDef<T> {
+}
+export interface $YatspExactOptionalInternals<T extends SomeType = $YatspType> extends $YatspOptionalInternals<T> {
+    def: $YatspExactOptionalDef<T>;
+    output: core.output<T>;
+    input: core.input<T>;
+}
+export interface $YatspExactOptional<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspExactOptionalInternals<T>;
+}
+export declare const $YatspExactOptional: core.$constructor<$YatspExactOptional>;
+export interface $YatspNullableDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "nullable";
+    innerType: T;
+}
+export interface $YatspNullableInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<T> | null, core.input<T> | null> {
+    def: $YatspNullableDef<T>;
+    optin: T["_yatsp"]["optin"];
+    optout: T["_yatsp"]["optout"];
+    isst: never;
+    values: T["_yatsp"]["values"];
+    pattern: T["_yatsp"]["pattern"];
+}
+export interface $YatspNullable<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspNullableInternals<T>;
+}
+export declare const $YatspNullable: core.$constructor<$YatspNullable>;
+export interface $YatspDefaultDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "default";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: util.NoUndefined<core.output<T>>;
+}
+export interface $YatspDefaultInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+    def: $YatspDefaultDef<T>;
+    optin: "defaulted";
+    optout?: "optional" | undefined;
+    isst: never;
+    values: T["_yatsp"]["values"];
+}
+export interface $YatspDefault<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspDefaultInternals<T>;
+}
+export declare const $YatspDefault: core.$constructor<$YatspDefault>;
+export interface $YatspPrefaultDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "prefault";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: core.input<T>;
+}
+export interface $YatspPrefaultInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<T>, core.input<T> | undefined> {
+    def: $YatspPrefaultDef<T>;
+    optin: "defaulted";
+    optout?: "optional" | undefined;
+    isst: never;
+    values: T["_yatsp"]["values"];
+}
+export interface $YatspPrefault<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspPrefaultInternals<T>;
+}
+export declare const $YatspPrefault: core.$constructor<$YatspPrefault>;
+export interface $YatspNonOptionalDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "nonoptional";
+    innerType: T;
+}
+export interface $YatspNonOptionalInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<util.NoUndefined<core.output<T>>, util.NoUndefined<core.input<T>>> {
+    def: $YatspNonOptionalDef<T>;
+    isst: errors.$YatspIssueInvalidType;
+    values: T["_yatsp"]["values"];
+    optin: "optional" | undefined;
+    optout: "optional" | undefined;
+}
+export interface $YatspNonOptional<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspNonOptionalInternals<T>;
+}
+export declare const $YatspNonOptional: core.$constructor<$YatspNonOptional>;
+export interface $YatspSuccessDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "success";
+    innerType: T;
+}
+export interface $YatspSuccessInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<boolean, core.input<T>> {
+    def: $YatspSuccessDef<T>;
+    isst: never;
+    optin: T["_yatsp"]["optin"];
+    optout: "optional" | undefined;
+}
+export interface $YatspSuccess<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspSuccessInternals<T>;
+}
+export declare const $YatspSuccess: core.$constructor<$YatspSuccess>;
+export interface $YatspCatchCtx extends ParsePayload {
+    /** @deprecated Use `ctx.issues` */
+    error: {
+        issues: errors.$YatspIssue[];
+    };
+    /** @deprecated Use `ctx.value` */
+    input: unknown;
+}
+export interface $YatspCatchDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "catch";
+    innerType: T;
+    catchValue: (ctx: $YatspCatchCtx) => unknown;
+}
+export interface $YatspCatchInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<T>, core.input<T>> {
+    def: $YatspCatchDef<T>;
+    optin: T["_yatsp"]["optin"];
+    optout: T["_yatsp"]["optout"];
+    isst: never;
+    values: T["_yatsp"]["values"];
+}
+export interface $YatspCatch<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspCatchInternals<T>;
+}
+export declare const $YatspCatch: core.$constructor<$YatspCatch>;
+export interface $YatspNaNDef extends $YatspTypeDef {
+    type: "nan";
+}
+export interface $YatspNaNInternals extends $YatspTypeInternals<number, number> {
+    def: $YatspNaNDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspNaN extends $YatspType {
+    _yatsp: $YatspNaNInternals;
+}
+export declare const $YatspNaN: core.$constructor<$YatspNaN>;
+export interface $YatspPipeDef<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "pipe";
+    in: A;
+    out: B;
+    /** Only defined inside $YatspCodec instances. */
+    transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
+    /** Only defined inside $YatspCodec instances. */
+    reverseTransform?: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
+}
+export interface $YatspPipeInternals<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<B>, core.input<A>> {
+    def: $YatspPipeDef<A, B>;
+    isst: never;
+    values: A["_yatsp"]["values"];
+    optin: A["_yatsp"]["optin"];
+    optout: B["_yatsp"]["optout"];
+    propValues: A["_yatsp"]["propValues"];
+}
+export interface $YatspPipe<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspPipeInternals<A, B>;
+}
+export declare const $YatspPipe: core.$constructor<$YatspPipe>;
+export interface $YatspCodecDef<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspPipeDef<A, B> {
+    transform: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
+    reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
+}
+export interface $YatspCodecInternals<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<B>, core.input<A>> {
+    def: $YatspCodecDef<A, B>;
+    isst: never;
+    values: A["_yatsp"]["values"];
+    optin: A["_yatsp"]["optin"];
+    optout: B["_yatsp"]["optout"];
+    propValues: A["_yatsp"]["propValues"];
+}
+export interface $YatspCodec<A extends SomeType = $YatspType, B extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspCodecInternals<A, B>;
+}
+export declare const $YatspCodec: core.$constructor<$YatspCodec>;
+export interface $YatspPreprocessDef<B extends SomeType = $YatspType, I = unknown> extends $YatspPipeDef<$YatspTransform<unknown, I>, B> {
+    in: $YatspTransform<unknown, I>;
+    out: B;
+}
+export interface $YatspPreprocessInternals<B extends SomeType = $YatspType, I = unknown> extends $YatspPipeInternals<$YatspTransform<unknown, I>, B> {
+    def: $YatspPreprocessDef<B, I>;
+    optin: B["_yatsp"]["optin"];
+    optout: B["_yatsp"]["optout"];
+}
+export interface $YatspPreprocess<B extends SomeType = $YatspType, I = unknown> extends $YatspPipe<$YatspTransform<unknown, I>, B> {
+    _yatsp: $YatspPreprocessInternals<B, I>;
+}
+export declare const $YatspPreprocess: core.$constructor<$YatspPreprocess>;
+export interface $YatspReadonlyDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "readonly";
+    innerType: T;
+}
+export interface $YatspReadonlyInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<util.MakeReadonly<core.output<T>>, util.MakeReadonly<core.input<T>>> {
+    def: $YatspReadonlyDef<T>;
+    optin: T["_yatsp"]["optin"];
+    optout: T["_yatsp"]["optout"];
+    isst: never;
+    propValues: T["_yatsp"]["propValues"];
+    values: T["_yatsp"]["values"];
+}
+export interface $YatspReadonly<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspReadonlyInternals<T>;
+}
+export declare const $YatspReadonly: core.$constructor<$YatspReadonly>;
+export interface $YatspTemplateLiteralDef extends $YatspTypeDef {
+    type: "template_literal";
+    parts: $YatspTemplateLiteralPart[];
+    format?: string | undefined;
+}
+export interface $YatspTemplateLiteralInternals<Template extends string = string> extends $YatspTypeInternals<Template, Template> {
+    pattern: RegExp;
+    def: $YatspTemplateLiteralDef;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspTemplateLiteral<Template extends string = string> extends $YatspType {
+    _yatsp: $YatspTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<util.Literal, symbol>;
+interface SchemaPartInternals extends $YatspTypeInternals<LiteralPart, LiteralPart> {
+    pattern: RegExp;
+}
+interface SchemaPart extends $YatspType {
+    _yatsp: SchemaPartInternals;
+}
+export type $YatspTemplateLiteralPart = LiteralPart | SchemaPart;
+type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
+type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $YatspType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $YatspType ? `${Template}${core.output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
+export type ConcatenateTupleOfStrings<T extends string[]> = T extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? Rest extends string[] ? First extends "" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : "";
+export type ConvertPartsToStringTuple<Parts extends $YatspTemplateLiteralPart[]> = {
+    [K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $YatspType ? `${core.output<Parts[K]> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
+};
+export type ToTemplateLiteral<Parts extends $YatspTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
+export type $PartsToTemplateLiteral<Parts extends $YatspTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $YatspTemplateLiteralPart] ? Rest extends $YatspTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
+export declare const $YatspTemplateLiteral: core.$constructor<$YatspTemplateLiteral>;
+export type $YatspFunctionArgs = $YatspType<unknown[], unknown[]>;
+export type $YatspFunctionIn = $YatspFunctionArgs;
+export type $YatspFunctionOut = $YatspType;
+export type $InferInnerFunctionType<Args extends $YatspFunctionIn, Returns extends $YatspFunctionOut> = (...args: $YatspFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
+export type $InferInnerFunctionTypeAsync<Args extends $YatspFunctionIn, Returns extends $YatspFunctionOut> = (...args: $YatspFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
+export type $InferOuterFunctionType<Args extends $YatspFunctionIn, Returns extends $YatspFunctionOut> = (...args: $YatspFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
+export type $InferOuterFunctionTypeAsync<Args extends $YatspFunctionIn, Returns extends $YatspFunctionOut> = (...args: $YatspFunctionIn extends Args ? never[] : core.input<Args>) => Promise<core.output<Returns>>;
+export interface $YatspFunctionDef<In extends $YatspFunctionIn = $YatspFunctionIn, Out extends $YatspFunctionOut = $YatspFunctionOut> extends $YatspTypeDef {
+    type: "function";
+    input: In;
+    output: Out;
+}
+export interface $YatspFunctionInternals<Args extends $YatspFunctionIn, Returns extends $YatspFunctionOut> extends $YatspTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+    def: $YatspFunctionDef<Args, Returns>;
+    isst: errors.$YatspIssueInvalidType;
+}
+export interface $YatspFunction<Args extends $YatspFunctionIn = $YatspFunctionIn, Returns extends $YatspFunctionOut = $YatspFunctionOut> extends $YatspType<any, any, $YatspFunctionInternals<Args, Returns>> {
+    /** @deprecated */
+    _def: $YatspFunctionDef<Args, Returns>;
+    _input: $InferInnerFunctionType<Args, Returns>;
+    _output: $InferOuterFunctionType<Args, Returns>;
+    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends $YatspFunctionOut = $YatspFunctionOut>(args: Items, rest?: Rest): $YatspFunction<$YatspTuple<Items, Rest>, Returns>;
+    input<NewArgs extends $YatspFunctionIn>(args: NewArgs): $YatspFunction<NewArgs, Returns>;
+    input(...args: any[]): $YatspFunction<any, Returns>;
+    output<NewReturns extends $YatspType>(output: NewReturns): $YatspFunction<Args, NewReturns>;
+}
+export interface $YatspFunctionParams<I extends $YatspFunctionIn, O extends $YatspType> {
+    input?: I;
+    output?: O;
+}
+export declare const $YatspFunction: core.$constructor<$YatspFunction>;
+export interface $YatspPromiseDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "promise";
+    innerType: T;
+}
+export interface $YatspPromiseInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
+    def: $YatspPromiseDef<T>;
+    isst: never;
+}
+export interface $YatspPromise<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspPromiseInternals<T>;
+}
+export declare const $YatspPromise: core.$constructor<$YatspPromise>;
+export interface $YatspLazyDef<T extends SomeType = $YatspType> extends $YatspTypeDef {
+    type: "lazy";
+    getter: () => T;
+}
+export interface $YatspLazyInternals<T extends SomeType = $YatspType> extends $YatspTypeInternals<core.output<T>, core.input<T>> {
+    def: $YatspLazyDef<T>;
+    isst: never;
+    /** Auto-cached way to retrieve the inner schema */
+    innerType: T;
+    pattern: T["_yatsp"]["pattern"];
+    propValues: T["_yatsp"]["propValues"];
+    optin: T["_yatsp"]["optin"];
+    optout: T["_yatsp"]["optout"];
+}
+export interface $YatspLazy<T extends SomeType = $YatspType> extends $YatspType {
+    _yatsp: $YatspLazyInternals<T>;
+}
+export declare const $YatspLazy: core.$constructor<$YatspLazy>;
+export interface $YatspCustomDef<O = unknown> extends $YatspTypeDef, checks.$YatspCheckDef {
+    type: "custom";
+    check: "custom";
+    path?: PropertyKey[] | undefined;
+    error?: errors.$YatspErrorMap | undefined;
+    params?: Record<string, any> | undefined;
+    fn: (arg: O) => unknown;
+}
+export interface $YatspCustomInternals<O = unknown, I = unknown> extends $YatspTypeInternals<O, I>, checks.$YatspCheckInternals<O> {
+    def: $YatspCustomDef;
+    issc: errors.$YatspIssue;
+    isst: never;
+    bag: util.LoosePartial<{
+        Class: typeof util.Class;
+    }>;
+}
+export interface $YatspCustom<O = unknown, I = unknown> extends $YatspType {
+    _yatsp: $YatspCustomInternals<O, I>;
+}
+export declare const $YatspCustom: core.$constructor<$YatspCustom>;
+export type $YatspTypes = $YatspString | $YatspNumber | $YatspBigInt | $YatspBoolean | $YatspDate | $YatspSymbol | $YatspUndefined | $YatspNullable | $YatspNull | $YatspAny | $YatspUnknown | $YatspNever | $YatspVoid | $YatspArray | $YatspObject | $YatspUnion | $YatspIntersection | $YatspTuple | $YatspRecord | $YatspMap | $YatspSet | $YatspLiteral | $YatspEnum | $YatspFunction | $YatspPromise | $YatspLazy | $YatspOptional | $YatspDefault | $YatspPrefault | $YatspTemplateLiteral | $YatspCustom | $YatspTransform | $YatspNonOptional | $YatspReadonly | $YatspNaN | $YatspPipe | $YatspSuccess | $YatspCatch | $YatspFile;
+export type $YatspStringFormatTypes = $YatspGUID | $YatspUUID | $YatspEmail | $YatspURL | $YatspEmoji | $YatspNanoID | $YatspCUID | $YatspCUID2 | $YatspULID | $YatspXID | $YatspKSUID | $YatspISODateTime | $YatspISODate | $YatspISOTime | $YatspISODuration | $YatspIPv4 | $YatspIPv6 | $YatspMAC | $YatspCIDRv4 | $YatspCIDRv6 | $YatspBase64 | $YatspBase64URL | $YatspE164 | $YatspCreditCard | $YatspIBAN | $YatspJWT | $YatspCustomStringFormat<"hex"> | $YatspCustomStringFormat<util.HashFormat> | $YatspCustomStringFormat<"hostname"> | $YatspCustomStringFormat<"currency_code">;