fullstacked 0.12.0-1173 → 0.12.0-1184

package/fullstacked_modules/zod/v4/core/checks.d.ts

@@ -0,0 +1,278 @@
+import * as core from "./core.js";
+import type * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+import * as util from "./util.js";
+export interface $ZodCheckDef {
+    check: string;
+    error?: errors.$ZodErrorMap<never> | undefined;
+    /** If true, no later checks will be executed if this check fails. Default `false`. */
+    abort?: boolean | undefined;
+    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
+}
+export interface $ZodCheckInternals<T> {
+    def: $ZodCheckDef;
+    /** The set of issues this check might throw. */
+    issc?: errors.$ZodIssueBase;
+    check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
+    onattach: ((schema: schemas.$ZodType) => void)[];
+}
+export interface $ZodCheck<in T = never> {
+    _zod: $ZodCheckInternals<T>;
+}
+export declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;
+export interface $ZodCheckLessThanDef extends $ZodCheckDef {
+    check: "less_than";
+    value: util.Numeric;
+    inclusive: boolean;
+}
+export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
+    def: $ZodCheckLessThanDef;
+    issc: errors.$ZodIssueTooBig<T>;
+}
+export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
+    _zod: $ZodCheckLessThanInternals<T>;
+}
+export declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;
+export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+    check: "greater_than";
+    value: util.Numeric;
+    inclusive: boolean;
+}
+export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
+    def: $ZodCheckGreaterThanDef;
+    issc: errors.$ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
+    _zod: $ZodCheckGreaterThanInternals<T>;
+}
+export declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;
+export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+    check: "multiple_of";
+    value: T;
+}
+export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMultipleOfDef<T>;
+    issc: errors.$ZodIssueNotMultipleOf;
+}
+export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+    _zod: $ZodCheckMultipleOfInternals<T>;
+}
+export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
+export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+export interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
+    check: "number_format";
+    format: $ZodNumberFormats;
+}
+export interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
+    def: $ZodCheckNumberFormatDef;
+    issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
+}
+export interface $ZodCheckNumberFormat extends $ZodCheck<number> {
+    _zod: $ZodCheckNumberFormatInternals;
+}
+export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
+export type $ZodBigIntFormats = "int64" | "uint64";
+export interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {
+    check: "bigint_format";
+    format: $ZodBigIntFormats | undefined;
+}
+export interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {
+    def: $ZodCheckBigIntFormatDef;
+    issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
+}
+export interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {
+    _zod: $ZodCheckBigIntFormatInternals;
+}
+export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
+export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
+    check: "max_size";
+    maximum: number;
+}
+export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMaxSizeDef;
+    issc: errors.$ZodIssueTooBig<T>;
+}
+export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
+    _zod: $ZodCheckMaxSizeInternals<T>;
+}
+export declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;
+export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
+    check: "min_size";
+    minimum: number;
+}
+export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMinSizeDef;
+    issc: errors.$ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
+    _zod: $ZodCheckMinSizeInternals<T>;
+}
+export declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;
+export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
+    check: "size_equals";
+    size: number;
+}
+export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
+    def: $ZodCheckSizeEqualsDef;
+    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
+    _zod: $ZodCheckSizeEqualsInternals<T>;
+}
+export declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;
+export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+    check: "max_length";
+    maximum: number;
+}
+export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMaxLengthDef;
+    issc: errors.$ZodIssueTooBig<T>;
+}
+export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMaxLengthInternals<T>;
+}
+export declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;
+export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+    check: "min_length";
+    minimum: number;
+}
+export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMinLengthDef;
+    issc: errors.$ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMinLengthInternals<T>;
+}
+export declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;
+export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+    check: "length_equals";
+    length: number;
+}
+export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckLengthEqualsDef;
+    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
+export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+    check: "string_format";
+    format: Format;
+    pattern?: RegExp | undefined;
+}
+export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStringFormatDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckStringFormat extends $ZodCheck<string> {
+    _zod: $ZodCheckStringFormatInternals;
+}
+export declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;
+export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+    format: "regex";
+    pattern: RegExp;
+}
+export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckRegexDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckRegex extends $ZodCheck<string> {
+    _zod: $ZodCheckRegexInternals;
+}
+export declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;
+export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
+}
+export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckLowerCaseDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckLowerCase extends $ZodCheck<string> {
+    _zod: $ZodCheckLowerCaseInternals;
+}
+export declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;
+export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
+}
+export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckUpperCaseDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckUpperCase extends $ZodCheck<string> {
+    _zod: $ZodCheckUpperCaseInternals;
+}
+export declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;
+export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+    includes: string;
+    position?: number | undefined;
+}
+export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckIncludesDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckIncludes extends $ZodCheck<string> {
+    _zod: $ZodCheckIncludesInternals;
+}
+export declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;
+export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+    prefix: string;
+}
+export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStartsWithDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckStartsWith extends $ZodCheck<string> {
+    _zod: $ZodCheckStartsWithInternals;
+}
+export declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;
+export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+    suffix: string;
+}
+export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckEndsWithDef;
+    issc: errors.$ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+    _zod: $ZodCheckEndsWithInternals;
+}
+export declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;
+export interface $ZodCheckPropertyDef extends $ZodCheckDef {
+    check: "property";
+    property: string;
+    schema: schemas.$ZodType;
+}
+export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
+    def: $ZodCheckPropertyDef;
+    issc: errors.$ZodIssue;
+}
+export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
+    _zod: $ZodCheckPropertyInternals<T>;
+}
+export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
+export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
+    check: "mime_type";
+    mime: util.MimeTypes[];
+}
+export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMimeTypeDef;
+    issc: errors.$ZodIssueInvalidValue;
+}
+export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
+    _zod: $ZodCheckMimeTypeInternals<T>;
+}
+export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;
+export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
+    check: "overwrite";
+    tx(value: T): T;
+}
+export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
+    def: $ZodCheckOverwriteDef<T>;
+    issc: never;
+}
+export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
+    _zod: $ZodCheckOverwriteInternals<T>;
+}
+export declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;
+export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
+export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;

package/fullstacked_modules/zod/v4/core/core.d.cts

@@ -0,0 +1,49 @@
+import type * as errors from "./errors.cjs";
+import type * as schemas from "./schemas.cjs";
+import type { Class } from "./util.cjs";
+type ZodTrait = {
+    _zod: {
+        def: any;
+        [k: string]: any;
+    };
+};
+export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+    new (def: D): T;
+    init(inst: T, def: D): asserts inst is T;
+}
+/** A special constant with type `never` */
+export declare const NEVER: never;
+export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+    Parent?: typeof Class;
+}): $constructor<T, D>;
+export declare const $brand: unique symbol;
+export type $brand<T extends string | number | symbol = string | number | symbol> = {
+    [$brand]: {
+        [k in T]: true;
+    };
+};
+export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+export declare class $ZodAsyncError extends Error {
+    constructor();
+}
+export type input<T> = T extends {
+    _zod: {
+        input: any;
+    };
+} ? Required<T["_zod"]>["input"] : unknown;
+export type output<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? Required<T["_zod"]>["output"] : unknown;
+export type { output as infer };
+export interface $ZodConfig {
+    /** Custom error map. Overrides `config().localeError`. */
+    customError?: errors.$ZodErrorMap | undefined;
+    /** Localized error map. Lowest priority. */
+    localeError?: errors.$ZodErrorMap | undefined;
+    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
+    jitless?: boolean | undefined;
+}
+export declare const globalConfig: $ZodConfig;
+export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;

package/fullstacked_modules/zod/v4/core/core.d.ts

@@ -0,0 +1,49 @@
+import type * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+import type { Class } from "./util.js";
+type ZodTrait = {
+    _zod: {
+        def: any;
+        [k: string]: any;
+    };
+};
+export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+    new (def: D): T;
+    init(inst: T, def: D): asserts inst is T;
+}
+/** A special constant with type `never` */
+export declare const NEVER: never;
+export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+    Parent?: typeof Class;
+}): $constructor<T, D>;
+export declare const $brand: unique symbol;
+export type $brand<T extends string | number | symbol = string | number | symbol> = {
+    [$brand]: {
+        [k in T]: true;
+    };
+};
+export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+export declare class $ZodAsyncError extends Error {
+    constructor();
+}
+export type input<T> = T extends {
+    _zod: {
+        input: any;
+    };
+} ? Required<T["_zod"]>["input"] : unknown;
+export type output<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? Required<T["_zod"]>["output"] : unknown;
+export type { output as infer };
+export interface $ZodConfig {
+    /** Custom error map. Overrides `config().localeError`. */
+    customError?: errors.$ZodErrorMap | undefined;
+    /** Localized error map. Lowest priority. */
+    localeError?: errors.$ZodErrorMap | undefined;
+    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
+    jitless?: boolean | undefined;
+}
+export declare const globalConfig: $ZodConfig;
+export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;

package/fullstacked_modules/zod/v4/core/doc.d.cts

@@ -0,0 +1,14 @@
+type ModeWriter = (doc: Doc, modes: {
+    execution: "sync" | "async";
+}) => void;
+export declare class Doc {
+    args: string[];
+    content: string[];
+    indent: number;
+    constructor(args?: string[]);
+    indented(fn: (doc: Doc) => void): void;
+    write(fn: ModeWriter): void;
+    write(line: string): void;
+    compile(): any;
+}
+export {};

package/fullstacked_modules/zod/v4/core/doc.d.ts

@@ -0,0 +1,14 @@
+type ModeWriter = (doc: Doc, modes: {
+    execution: "sync" | "async";
+}) => void;
+export declare class Doc {
+    args: string[];
+    content: string[];
+    indent: number;
+    constructor(args?: string[]);
+    indented(fn: (doc: Doc) => void): void;
+    write(fn: ModeWriter): void;
+    write(line: string): void;
+    compile(): any;
+}
+export {};

package/fullstacked_modules/zod/v4/core/errors.d.cts

@@ -0,0 +1,210 @@
+import type { $ZodCheck, $ZodStringFormats } from "./checks.cjs";
+import { $constructor } from "./core.cjs";
+import type { $ZodType } from "./schemas.cjs";
+import type { StandardSchemaV1 } from "./standard-schema.cjs";
+import * as util from "./util.cjs";
+export interface $ZodIssueBase {
+    readonly code?: string;
+    readonly input?: unknown;
+    readonly path: PropertyKey[];
+    readonly message: string;
+}
+export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_type";
+    readonly expected: $ZodType["_zod"]["def"]["type"];
+    readonly input?: Input;
+}
+export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_big";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly maximum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly exact?: boolean;
+    readonly input?: Input;
+}
+export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_small";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly minimum: number | bigint;
+    /** True if the allowable range includes the minimum */
+    readonly inclusive?: boolean;
+    /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+    readonly exact?: boolean;
+    readonly input?: Input;
+}
+export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+    readonly code: "invalid_format";
+    readonly format: $ZodStringFormats | (string & {});
+    readonly pattern?: string;
+    readonly input?: string;
+}
+export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+    readonly code: "not_multiple_of";
+    readonly divisor: number;
+    readonly input?: Input;
+}
+export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+    readonly code: "unrecognized_keys";
+    readonly keys: string[];
+    readonly input?: Record<string, unknown>;
+}
+export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+    readonly code: "invalid_union";
+    readonly errors: $ZodIssue[][];
+    readonly input?: unknown;
+    readonly discriminator?: string | undefined;
+}
+export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_key";
+    readonly origin: "map" | "record";
+    readonly issues: $ZodIssue[];
+    readonly input?: Input;
+}
+export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_element";
+    readonly origin: "map" | "set";
+    readonly key: unknown;
+    readonly issues: $ZodIssue[];
+    readonly input?: Input;
+}
+export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_value";
+    readonly values: util.Primitive[];
+    readonly input?: Input;
+}
+export interface $ZodIssueCustom extends $ZodIssueBase {
+    readonly code: "custom";
+    readonly params?: Record<string, any> | undefined;
+    readonly input?: unknown;
+}
+export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
+    format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
+}
+export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
+    format: "regex";
+    pattern: string;
+}
+export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
+    format: "jwt";
+    algorithm?: string;
+}
+export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
+    format: "starts_with";
+    prefix: string;
+}
+export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
+    format: "ends_with";
+    suffix: string;
+}
+export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
+    format: "includes";
+    includes: string;
+}
+export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
+export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+export type $ZodIssueCode = $ZodIssue["code"];
+export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
+    /** The input data */
+    readonly input: unknown;
+    /** The schema or check that originated this issue. */
+    readonly inst?: $ZodType | $ZodCheck;
+    /** If `true`, Zod will continue executing checks/refinements after this issue. */
+    readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+    (issue: $ZodRawIssue<T>): {
+        message: string;
+    } | string | undefined | null;
+}
+export interface $ZodError<T = unknown> extends Error {
+    type: T;
+    issues: $ZodIssue[];
+    _zod: {
+        output: T;
+        def: $ZodIssue[];
+    };
+    stack?: string;
+    name: string;
+}
+export declare const $ZodError: $constructor<$ZodError>;
+interface $ZodRealError<T = any> extends $ZodError<T> {
+}
+export declare const $ZodRealError: $constructor<$ZodRealError>;
+export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in keyof T]?: U[];
+    };
+};
+export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
+export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+} : T extends any[] ? {
+    [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? util.Flatten<{
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+}> : any;
+export type $ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & util.Flatten<_ZodFormattedError<T, U>>;
+export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
+export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
+    errors: U[];
+} : T extends [any, ...any[]] ? {
+    errors: U[];
+    items?: {
+        [K in keyof T]?: $ZodErrorTree<T[K], U>;
+    };
+} : T extends any[] ? {
+    errors: U[];
+    items?: Array<$ZodErrorTree<T[number], U>>;
+} : T extends object ? {
+    errors: U[];
+    properties?: {
+        [K in keyof T]?: $ZodErrorTree<T[K], U>;
+    };
+} : {
+    errors: U[];
+};
+export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
+export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
+/** Format a ZodError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * ZodError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
+export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
+export {};