@willaimg/yatsp 4.3.6

package/v4/mini/schemas.d.cts

@@ -0,0 +1,480 @@
+import * as core from "../core/index.cjs";
+import type { $YatspBigIntFormats } from "../core/index.cjs";
+import * as util from "../core/util.cjs";
+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 declare const YatspMiniType: core.$constructor<YatspMiniType>;
+export interface _YatspMiniString<T extends core.$YatspStringInternals<unknown> = core.$YatspStringInternals<unknown>> extends _YatspMiniType<T>, core.$YatspString<T["input"]> {
+    _yatsp: T;
+}
+export interface YatspMiniString<Input = unknown> extends _YatspMiniString<core.$YatspStringInternals<Input>>, core.$YatspString<Input> {
+}
+export declare const YatspMiniString: core.$constructor<YatspMiniString>;
+export declare function string(params?: string | core.$YatspStringParams): YatspMiniString<string>;
+export interface YatspMiniStringFormat<Format extends string = string> extends _YatspMiniString<core.$YatspStringFormatInternals<Format>>, core.$YatspStringFormat<Format> {
+}
+export declare const YatspMiniStringFormat: core.$constructor<YatspMiniStringFormat>;
+export interface YatspMiniEmail extends _YatspMiniString<core.$YatspEmailInternals> {
+}
+export declare const YatspMiniEmail: core.$constructor<YatspMiniEmail>;
+export declare function email(params?: string | core.$YatspEmailParams): YatspMiniEmail;
+export interface YatspMiniGUID extends _YatspMiniString<core.$YatspGUIDInternals> {
+}
+export declare const YatspMiniGUID: core.$constructor<YatspMiniGUID>;
+export declare function guid(params?: string | core.$YatspGUIDParams): YatspMiniGUID;
+export interface YatspMiniUUID extends _YatspMiniString<core.$YatspUUIDInternals> {
+}
+export declare const YatspMiniUUID: core.$constructor<YatspMiniUUID>;
+export declare function uuid(params?: string | core.$YatspUUIDParams): YatspMiniUUID;
+export declare function uuidv4(params?: string | core.$YatspUUIDv4Params): YatspMiniUUID;
+export declare function uuidv6(params?: string | core.$YatspUUIDv6Params): YatspMiniUUID;
+export declare function uuidv7(params?: string | core.$YatspUUIDv7Params): YatspMiniUUID;
+export interface YatspMiniURL extends _YatspMiniString<core.$YatspURLInternals> {
+}
+export declare const YatspMiniURL: core.$constructor<YatspMiniURL>;
+export declare function url(params?: string | core.$YatspURLParams): YatspMiniURL;
+export declare function httpUrl(params?: string | Omit<core.$YatspURLParams, "protocol" | "hostname">): YatspMiniURL;
+export interface YatspMiniEmoji extends _YatspMiniString<core.$YatspEmojiInternals> {
+}
+export declare const YatspMiniEmoji: core.$constructor<YatspMiniEmoji>;
+export declare function emoji(params?: string | core.$YatspEmojiParams): YatspMiniEmoji;
+export interface YatspMiniNanoID extends _YatspMiniString<core.$YatspNanoIDInternals> {
+}
+export declare const YatspMiniNanoID: core.$constructor<YatspMiniNanoID>;
+export declare function nanoid(params?: string | core.$YatspNanoIDParams): YatspMiniNanoID;
+/**
+ * @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> {
+}
+/**
+ * @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 declare const YatspMiniCUID: core.$constructor<YatspMiniCUID>;
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export declare function cuid(params?: string | core.$YatspCUIDParams): YatspMiniCUID;
+export interface YatspMiniCUID2 extends _YatspMiniString<core.$YatspCUID2Internals> {
+}
+export declare const YatspMiniCUID2: core.$constructor<YatspMiniCUID2>;
+export declare function cuid2(params?: string | core.$YatspCUID2Params): YatspMiniCUID2;
+export interface YatspMiniULID extends _YatspMiniString<core.$YatspULIDInternals> {
+}
+export declare const YatspMiniULID: core.$constructor<YatspMiniULID>;
+export declare function ulid(params?: string | core.$YatspULIDParams): YatspMiniULID;
+export interface YatspMiniXID extends _YatspMiniString<core.$YatspXIDInternals> {
+}
+export declare const YatspMiniXID: core.$constructor<YatspMiniXID>;
+export declare function xid(params?: string | core.$YatspXIDParams): YatspMiniXID;
+export interface YatspMiniKSUID extends _YatspMiniString<core.$YatspKSUIDInternals> {
+}
+export declare const YatspMiniKSUID: core.$constructor<YatspMiniKSUID>;
+export declare function ksuid(params?: string | core.$YatspKSUIDParams): YatspMiniKSUID;
+export interface YatspMiniIPv4 extends _YatspMiniString<core.$YatspIPv4Internals> {
+}
+export declare const YatspMiniIPv4: core.$constructor<YatspMiniIPv4>;
+export declare function ipv4(params?: string | core.$YatspIPv4Params): YatspMiniIPv4;
+export interface YatspMiniIPv6 extends _YatspMiniString<core.$YatspIPv6Internals> {
+}
+export declare const YatspMiniIPv6: core.$constructor<YatspMiniIPv6>;
+export declare function ipv6(params?: string | core.$YatspIPv6Params): YatspMiniIPv6;
+export interface YatspMiniCIDRv4 extends _YatspMiniString<core.$YatspCIDRv4Internals> {
+}
+export declare const YatspMiniCIDRv4: core.$constructor<YatspMiniCIDRv4>;
+export declare function cidrv4(params?: string | core.$YatspCIDRv4Params): YatspMiniCIDRv4;
+export interface YatspMiniCIDRv6 extends _YatspMiniString<core.$YatspCIDRv6Internals> {
+}
+export declare const YatspMiniCIDRv6: core.$constructor<YatspMiniCIDRv6>;
+export declare function cidrv6(params?: string | core.$YatspCIDRv6Params): YatspMiniCIDRv6;
+export interface YatspMiniMAC extends _YatspMiniString<core.$YatspMACInternals> {
+}
+export declare const YatspMiniMAC: core.$constructor<YatspMiniMAC>;
+export declare function mac(params?: string | core.$YatspMACParams): YatspMiniMAC;
+export interface YatspMiniBase64 extends _YatspMiniString<core.$YatspBase64Internals> {
+}
+export declare const YatspMiniBase64: core.$constructor<YatspMiniBase64>;
+export declare function base64(params?: string | core.$YatspBase64Params): YatspMiniBase64;
+export interface YatspMiniBase64URL extends _YatspMiniString<core.$YatspBase64URLInternals> {
+}
+export declare const YatspMiniBase64URL: core.$constructor<YatspMiniBase64URL>;
+export declare function base64url(params?: string | core.$YatspBase64URLParams): YatspMiniBase64URL;
+export interface YatspMiniE164 extends _YatspMiniString<core.$YatspE164Internals> {
+}
+export declare const YatspMiniE164: core.$constructor<YatspMiniE164>;
+export declare function e164(params?: string | core.$YatspE164Params): YatspMiniE164;
+export interface YatspMiniCreditCard extends _YatspMiniString<core.$YatspCreditCardInternals> {
+}
+export declare const YatspMiniCreditCard: core.$constructor<YatspMiniCreditCard>;
+export declare function creditCard(params?: string | core.$YatspCreditCardParams): YatspMiniCreditCard;
+export interface YatspMiniIBAN extends _YatspMiniString<core.$YatspIBANInternals> {
+}
+export declare const YatspMiniIBAN: core.$constructor<YatspMiniIBAN>;
+export declare function iban(params?: string | core.$YatspIBANParams): YatspMiniIBAN;
+export interface YatspMiniJWT extends _YatspMiniString<core.$YatspJWTInternals> {
+}
+export declare const YatspMiniJWT: core.$constructor<YatspMiniJWT>;
+export declare function jwt(params?: string | core.$YatspJWTParams): YatspMiniJWT;
+export interface YatspMiniCustomStringFormat<Format extends string = string> extends YatspMiniStringFormat<Format>, core.$YatspCustomStringFormat<Format> {
+    _yatsp: core.$YatspCustomStringFormatInternals<Format>;
+}
+export declare const YatspMiniCustomStringFormat: core.$constructor<YatspMiniCustomStringFormat>;
+export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<"hostname">;
+export declare function hex(_params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | core.$YatspStringFormatParams): YatspMiniCustomStringFormat<"currency_code">;
+export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$YatspStringFormatParams): YatspMiniCustomStringFormat<`${Alg}_${Enc}`>;
+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 declare const YatspMiniNumber: core.$constructor<YatspMiniNumber>;
+export declare function number(params?: string | core.$YatspNumberParams): YatspMiniNumber<number>;
+export interface YatspMiniNumberFormat<Format extends core.$YatspNumberFormats = core.$YatspNumberFormats> extends _YatspMiniNumber<core.$YatspNumberFormatInternals<Format>>, core.$YatspNumberFormat<Format> {
+}
+export declare const YatspMiniNumberFormat: core.$constructor<YatspMiniNumberFormat>;
+export interface YatspMiniInt extends YatspMiniNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniInt;
+export interface YatspMiniFloat32 extends YatspMiniNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniFloat32;
+export interface YatspMiniFloat64 extends YatspMiniNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniFloat64;
+export interface YatspMiniInt32 extends YatspMiniNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniInt32;
+export interface YatspMiniUInt32 extends YatspMiniNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$YatspCheckNumberFormatParams): YatspMiniUInt32;
+export interface YatspMiniBoolean<T = unknown> extends _YatspMiniType<core.$YatspBooleanInternals<T>> {
+}
+export declare const YatspMiniBoolean: core.$constructor<YatspMiniBoolean>;
+export declare function boolean(params?: string | core.$YatspBooleanParams): YatspMiniBoolean<boolean>;
+export interface YatspMiniBigInt<T = unknown> extends _YatspMiniType<core.$YatspBigIntInternals<T>>, core.$YatspBigInt<T> {
+}
+export declare const YatspMiniBigInt: core.$constructor<YatspMiniBigInt>;
+export declare function bigint(params?: string | core.$YatspBigIntParams): YatspMiniBigInt<bigint>;
+export interface YatspMiniBigIntFormat<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends _YatspMiniType<core.$YatspBigIntFormatInternals<Format>> {
+}
+export declare const YatspMiniBigIntFormat: core.$constructor<YatspMiniBigIntFormat>;
+export interface YatspMiniInt64 extends YatspMiniBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$YatspBigIntFormatParams): YatspMiniInt64;
+export interface YatspMiniUInt64 extends YatspMiniBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$YatspBigIntFormatParams): YatspMiniUInt64;
+export interface YatspMiniSymbol extends _YatspMiniType<core.$YatspSymbolInternals> {
+}
+export declare const YatspMiniSymbol: core.$constructor<YatspMiniSymbol>;
+export declare function symbol(params?: string | core.$YatspSymbolParams): YatspMiniSymbol;
+export interface YatspMiniUndefined extends _YatspMiniType<core.$YatspUndefinedInternals> {
+}
+export declare const YatspMiniUndefined: core.$constructor<YatspMiniUndefined>;
+declare function _undefined(params?: string | core.$YatspUndefinedParams): YatspMiniUndefined;
+export { _undefined as undefined };
+export interface YatspMiniNull extends _YatspMiniType<core.$YatspNullInternals> {
+}
+export declare const YatspMiniNull: core.$constructor<YatspMiniNull>;
+declare function _null(params?: string | core.$YatspNullParams): YatspMiniNull;
+export { _null as null };
+export interface YatspMiniAny extends _YatspMiniType<core.$YatspAnyInternals> {
+}
+export declare const YatspMiniAny: core.$constructor<YatspMiniAny>;
+export declare function any(): YatspMiniAny;
+export interface YatspMiniUnknown extends _YatspMiniType<core.$YatspUnknownInternals> {
+}
+export declare const YatspMiniUnknown: core.$constructor<YatspMiniUnknown>;
+export declare function unknown(): YatspMiniUnknown;
+export interface YatspMiniNever extends _YatspMiniType<core.$YatspNeverInternals> {
+}
+export declare const YatspMiniNever: core.$constructor<YatspMiniNever>;
+export declare function never(params?: string | core.$YatspNeverParams): YatspMiniNever;
+export interface YatspMiniVoid extends _YatspMiniType<core.$YatspVoidInternals> {
+}
+export declare const YatspMiniVoid: core.$constructor<YatspMiniVoid>;
+declare function _void(params?: string | core.$YatspVoidParams): YatspMiniVoid;
+export { _void as void };
+export interface YatspMiniDate<T = unknown> extends _YatspMiniType<core.$YatspDateInternals<T>> {
+}
+export declare const YatspMiniDate: core.$constructor<YatspMiniDate>;
+export declare function date(params?: string | core.$YatspDateParams): YatspMiniDate<Date>;
+export interface YatspMiniArray<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspArrayInternals<T>>, core.$YatspArray<T> {
+}
+export declare const YatspMiniArray: core.$constructor<YatspMiniArray>;
+export declare function array<T extends SomeType>(element: T, params?: string | core.$YatspArrayParams): YatspMiniArray<T>;
+export declare function keyof<T extends YatspMiniObject>(schema: T): YatspMiniEnum<util.KeysEnum<T["shape"]>>;
+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 declare const YatspMiniObject: core.$constructor<YatspMiniObject>;
+export declare function object<T extends core.$YatspLooseShape = Record<never, SomeType>>(shape?: T, params?: string | core.$YatspObjectParams): YatspMiniObject<util.Writeable<T>, core.$strip>;
+export declare function strictObject<T extends core.$YatspLooseShape>(shape: T, params?: string | core.$YatspObjectParams): YatspMiniObject<util.Writeable<T>, core.$strict>;
+export declare function looseObject<T extends core.$YatspLooseShape>(shape: T, params?: string | core.$YatspObjectParams): YatspMiniObject<util.Writeable<T>, core.$loose>;
+export declare function extend<T extends YatspMiniObject, U extends core.$YatspLooseShape>(schema: T, shape: U): YatspMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_yatsp"]["config"]>;
+export type SafeExtendShape<Base extends core.$YatspShape, Ext extends core.$YatspLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
+};
+export declare 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"]>;
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://yatsp.dev/api?id=extend) instead.
+ */
+export declare function merge<T extends YatspMiniObject, U extends YatspMiniObject>(a: T, b: U): YatspMiniObject<util.Extend<T["shape"], U["shape"]>, U["_yatsp"]["config"]>;
+export declare 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"]>;
+export declare 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"]>;
+export declare function partial<T extends YatspMiniObject>(schema: T): YatspMiniObject<{
+    -readonly [k in keyof T["shape"]]: YatspMiniOptional<T["shape"][k]>;
+}, T["_yatsp"]["config"]>;
+export declare 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"]>;
+export declare function partial<T extends util.TupleItems, Rest extends SomeType | null>(schema: YatspMiniTuple<T, Rest>): YatspMiniTuple<{
+    -readonly [k in keyof T]: YatspMiniOptional<T[k]>;
+}, Rest>;
+export declare function exactPartial<T extends YatspMiniObject>(schema: T): YatspMiniObject<{
+    -readonly [k in keyof T["shape"]]: YatspMiniExactOptional<T["shape"][k]>;
+}, T["_yatsp"]["config"]>;
+export declare 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"]>;
+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];
+}>;
+export declare function required<T extends YatspMiniObject>(schema: T): YatspMiniObject<{
+    -readonly [k in keyof T["shape"]]: YatspMiniNonOptional<T["shape"][k]>;
+}, T["_yatsp"]["config"]>;
+export declare 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"]>;
+export declare function catchall<T extends YatspMiniObject, U extends SomeType>(inst: T, catchall: U): YatspMiniObject<T["shape"], core.$catchall<U>>;
+export interface YatspMiniUnion<T extends readonly SomeType[] = readonly core.$YatspType[]> extends _YatspMiniType<core.$YatspUnionInternals<T>> {
+}
+export declare const YatspMiniUnion: core.$constructor<YatspMiniUnion>;
+export declare function union<const T extends readonly SomeType[]>(options: T, params?: string | core.$YatspUnionParams): YatspMiniUnion<T>;
+export interface YatspMiniXor<T extends readonly SomeType[] = readonly core.$YatspType[]> extends _YatspMiniType<core.$YatspXorInternals<T>> {
+}
+export declare const YatspMiniXor: core.$constructor<YatspMiniXor>;
+/** 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 declare function xor<const T extends readonly SomeType[]>(options: T, params?: string | core.$YatspXorParams): YatspMiniXor<T>;
+export interface YatspMiniDiscriminatedUnion<Options extends readonly SomeType[] = readonly core.$YatspType[], Disc extends string = string> extends YatspMiniUnion<Options> {
+    _yatsp: core.$YatspDiscriminatedUnionInternals<Options, Disc>;
+}
+export declare const YatspMiniDiscriminatedUnion: core.$constructor<YatspMiniDiscriminatedUnion>;
+export declare function discriminatedUnion<Types extends readonly [core.$YatspTypeDiscriminable, ...core.$YatspTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$YatspDiscriminatedUnionParams): YatspMiniDiscriminatedUnion<Types, Disc>;
+export interface YatspMiniIntersection<A extends SomeType = core.$YatspType, B extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspIntersectionInternals<A, B>> {
+}
+export declare const YatspMiniIntersection: core.$constructor<YatspMiniIntersection>;
+export declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): YatspMiniIntersection<T, U>;
+export interface YatspMiniTuple<T extends util.TupleItems = readonly core.$YatspType[], Rest extends SomeType | null = core.$YatspType | null> extends _YatspMiniType<core.$YatspTupleInternals<T, Rest>> {
+}
+export declare const YatspMiniTuple: core.$constructor<YatspMiniTuple>;
+export declare function tuple<const T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | core.$YatspTupleParams): YatspMiniTuple<T, null>;
+export declare function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | core.$YatspTupleParams): YatspMiniTuple<T, Rest>;
+export declare function tuple(items: [], params?: string | core.$YatspTupleParams): YatspMiniTuple<[], null>;
+export interface YatspMiniRecord<Key extends core.$YatspRecordKey = core.$YatspRecordKey, Value extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspRecordInternals<Key, Value>> {
+}
+export declare const YatspMiniRecord: core.$constructor<YatspMiniRecord>;
+export declare function record<Key extends core.$YatspRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspMiniRecord<Key, Value>;
+export declare function partialRecord<Key extends core.$YatspRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspMiniRecord<Key & core.$partial, Value>;
+export declare function looseRecord<Key extends core.$YatspRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspMiniRecord<Key, Value>;
+export interface YatspMiniMap<Key extends SomeType = core.$YatspType, Value extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspMapInternals<Key, Value>> {
+}
+export declare const YatspMiniMap: core.$constructor<YatspMiniMap>;
+export declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspMapParams): YatspMiniMap<Key, Value>;
+export interface YatspMiniSet<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspSetInternals<T>> {
+}
+export declare const YatspMiniSet: core.$constructor<YatspMiniSet>;
+export declare function set<Value extends SomeType>(valueType: Value, params?: string | core.$YatspSetParams): YatspMiniSet<Value>;
+export interface YatspMiniEnum<T extends util.EnumLike = util.EnumLike> extends _YatspMiniType<core.$YatspEnumInternals<T>> {
+    options: Array<T[keyof T]>;
+}
+export declare const YatspMiniEnum: core.$constructor<YatspMiniEnum>;
+declare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$YatspEnumParams): YatspMiniEnum<util.ToEnum<T[number]>>;
+declare function _enum<T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspMiniEnum<T>;
+export { _enum as enum };
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspMiniEnum<T>;
+export interface YatspMiniLiteral<T extends util.Literal = util.Literal> extends _YatspMiniType<core.$YatspLiteralInternals<T>> {
+}
+export declare const YatspMiniLiteral: core.$constructor<YatspMiniLiteral>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$YatspLiteralParams): YatspMiniLiteral<T[number]>;
+export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$YatspLiteralParams): YatspMiniLiteral<T>;
+export interface YatspMiniFile extends _YatspMiniType<core.$YatspFileInternals> {
+}
+export declare const YatspMiniFile: core.$constructor<YatspMiniFile>;
+export declare function file(params?: string | core.$YatspFileParams): YatspMiniFile;
+export interface YatspMiniTransform<O = unknown, I = unknown> extends _YatspMiniType<core.$YatspTransformInternals<O, I>> {
+}
+export declare const YatspMiniTransform: core.$constructor<YatspMiniTransform>;
+export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): YatspMiniTransform<Awaited<O>, I>;
+export interface YatspMiniOptional<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspOptionalInternals<T>>, core.$YatspOptional<T> {
+}
+export declare const YatspMiniOptional: core.$constructor<YatspMiniOptional>;
+export declare function optional<T extends SomeType>(innerType: T): YatspMiniOptional<T>;
+export interface YatspMiniExactOptional<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspExactOptionalInternals<T>>, core.$YatspExactOptional<T> {
+}
+export declare const YatspMiniExactOptional: core.$constructor<YatspMiniExactOptional>;
+export declare function exactOptional<T extends SomeType>(innerType: T): YatspMiniExactOptional<T>;
+export interface YatspMiniNullable<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspNullableInternals<T>> {
+}
+export declare const YatspMiniNullable: core.$constructor<YatspMiniNullable>;
+export declare function nullable<T extends SomeType>(innerType: T): YatspMiniNullable<T>;
+export declare function nullish<T extends SomeType>(innerType: T): YatspMiniOptional<YatspMiniNullable<T>>;
+export interface YatspMiniDefault<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspDefaultInternals<T>> {
+}
+export declare const YatspMiniDefault: core.$constructor<YatspMiniDefault>;
+export declare function _default<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): YatspMiniDefault<T>;
+export interface YatspMiniPrefault<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspPrefaultInternals<T>> {
+}
+export declare const YatspMiniPrefault: core.$constructor<YatspMiniPrefault>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): YatspMiniPrefault<T>;
+export interface YatspMiniNonOptional<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspNonOptionalInternals<T>> {
+}
+export declare const YatspMiniNonOptional: core.$constructor<YatspMiniNonOptional>;
+export declare function nonoptional<T extends SomeType>(innerType: T, params?: string | core.$YatspNonOptionalParams): YatspMiniNonOptional<T>;
+export interface YatspMiniSuccess<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspSuccessInternals<T>> {
+}
+export declare const YatspMiniSuccess: core.$constructor<YatspMiniSuccess>;
+export declare function success<T extends SomeType>(innerType: T): YatspMiniSuccess<T>;
+export interface YatspMiniCatch<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspCatchInternals<T>> {
+}
+export declare const YatspMiniCatch: core.$constructor<YatspMiniCatch>;
+declare function _catch<T extends SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$YatspCatchCtx) => core.output<T>)): YatspMiniCatch<T>;
+export { _catch as catch };
+export interface YatspMiniNaN extends _YatspMiniType<core.$YatspNaNInternals> {
+}
+export declare const YatspMiniNaN: core.$constructor<YatspMiniNaN>;
+export declare function nan(params?: string | core.$YatspNaNParams): YatspMiniNaN;
+export interface YatspMiniPipe<A extends SomeType = core.$YatspType, B extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspPipeInternals<A, B>> {
+}
+export declare const YatspMiniPipe: core.$constructor<YatspMiniPipe>;
+export declare 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>;
+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 declare const YatspMiniCodec: core.$constructor<YatspMiniCodec>;
+export declare 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>;
+export declare function invertCodec<A extends SomeType, B extends SomeType>(codec: YatspMiniCodec<A, B>): YatspMiniCodec<B, A>;
+export interface YatspMiniReadonly<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspReadonlyInternals<T>> {
+}
+export declare const YatspMiniReadonly: core.$constructor<YatspMiniReadonly>;
+export declare function readonly<T extends SomeType>(innerType: T): YatspMiniReadonly<T>;
+export interface YatspMiniTemplateLiteral<Template extends string = string> extends _YatspMiniType<core.$YatspTemplateLiteralInternals<Template>> {
+}
+export declare const YatspMiniTemplateLiteral: core.$constructor<YatspMiniTemplateLiteral>;
+export declare function templateLiteral<const Parts extends core.$YatspTemplateLiteralPart[]>(parts: Parts, params?: string | core.$YatspTemplateLiteralParams): YatspMiniTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
+export interface YatspMiniLazy<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspLazyInternals<T>> {
+}
+export declare const YatspMiniLazy: core.$constructor<YatspMiniLazy>;
+declare function _lazy<T extends SomeType>(getter: () => T): YatspMiniLazy<T>;
+export { _lazy as lazy };
+export interface YatspMiniPromise<T extends SomeType = core.$YatspType> extends _YatspMiniType<core.$YatspPromiseInternals<T>> {
+}
+export declare const YatspMiniPromise: core.$constructor<YatspMiniPromise>;
+export declare function promise<T extends SomeType>(innerType: T): YatspMiniPromise<T>;
+export interface YatspMiniCustom<O = unknown, I = unknown> extends _YatspMiniType<core.$YatspCustomInternals<O, I>> {
+}
+export declare const YatspMiniCustom: core.$constructor<YatspMiniCustom>;
+export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$YatspCustomParams): core.$YatspCheck<O>;
+export declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$YatspCustomParams | undefined): YatspMiniCustom<O, I>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$YatspCustomParams): core.$YatspCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>, params?: core.$YatspSuperRefineParams): core.$YatspCheck<T>;
+export declare const describe: typeof core.describe;
+export declare const meta: typeof core.meta;
+declare abstract class Class {
+    constructor(..._args: any[]);
+}
+declare function _instanceof<T extends typeof Class>(cls: T, params?: core.$YatspCustomParams): YatspMiniCustom<InstanceType<T>, InstanceType<T>>;
+export { _instanceof as instanceof };
+export declare const stringbool: (_params?: string | core.$YatspStringBoolParams) => YatspMiniCodec<YatspMiniString, YatspMiniBoolean>;
+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;
+}
+export declare function json(): YatspMiniJSONSchema;
+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 declare const YatspMiniFunction: core.$constructor<YatspMiniFunction>;
+export declare function _function(): YatspMiniFunction;
+export declare function _function<const In extends Array<SomeType> = Array<SomeType>>(params: {
+    input: In;
+}): YatspMiniFunction<YatspMiniTuple<In, null>, core.$YatspFunctionOut>;
+export declare 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 declare function _function<const In extends core.$YatspFunctionIn = core.$YatspFunctionIn>(params: {
+    input: In;
+}): YatspMiniFunction<In, core.$YatspFunctionOut>;
+export declare function _function<const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params: {
+    output: Out;
+}): YatspMiniFunction<core.$YatspFunctionIn, Out>;
+export declare function _function<In extends core.$YatspFunctionIn = core.$YatspFunctionIn, Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params?: {
+    input: In;
+    output: Out;
+}): YatspMiniFunction<In, Out>;
+export { _function as function };