@mastra/voice-aws-nova-sonic 0.2.2 → 0.2.3

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/request-context/index.d.ts

@@ -55,6 +55,19 @@ declare const MASTRA_AUTH_TOKEN_KEY = "mastra__authToken";
  * nested delegated runs. Internal to delegation — do not set it yourself.
  */
 declare const MASTRA_INHERITED_MEMORY_KEY = "mastra__inheritedMemory";
+/**
+ * Reserved key naming who sent a user message: `{ id, name?, avatarUrl? }`.
+ * Set by the host that authenticated the request; the agent-controller copies
+ * it onto the sent message as `providerMetadata.mastra.author` so a shared
+ * thread can show who wrote what.
+ *
+ * @example
+ * ```typescript
+ * // In your auth middleware:
+ * requestContext.setRaw(MASTRA_MESSAGE_AUTHOR_KEY, { id: user.id, name: user.name, avatarUrl: user.avatarUrl });
+ * ```
+ */
+declare const MASTRA_MESSAGE_AUTHOR_KEY = "mastra__messageAuthor";
 type VersionSelector = {
   versionId: string;
 } | {
@@ -66,6 +79,27 @@ type VersionOverrides = {
   defaultStatus?: 'draft' | 'published';
 };
 declare function mergeVersionOverrides(base?: VersionOverrides, overrides?: VersionOverrides): VersionOverrides | undefined;
+/**
+ * Carries typed, request-specific values through agents, tools, and workflows.
+ * Pass the instance as `requestContext` when starting an operation.
+ *
+ * @example
+ * ```typescript
+ * import { RequestContext } from '@mastra/core/request-context';
+ *
+ * const requestContext = new RequestContext<{ locale: string }>([
+ *   ['locale', 'en'],
+ * ]);
+ * ```
+ *
+ * @see For documentation bundled with your installed package, locate
+ * `@mastra/core/package.json` with your project's resolver or package-manager
+ * tooling, then read `dist/docs/SKILL.md` from that package root and follow its
+ * reference links. Use package-manager tools for virtual or archived packages.
+ *
+ * @see [Request context documentation](https://mastra.ai/docs/server/request-context)
+ * if packaged docs are unavailable.
+ */
 declare class RequestContext<Values extends Record<string, any> | unknown = unknown> {
   private registry;
   constructor(iterable?: Values extends Record<string, any> ? RecordToTuple<Partial<Values>> : Iterable<readonly [string, unknown]>);
@@ -215,5 +249,5 @@ declare class RequestContext<Values extends Record<string, any> | unknown = unkn
   get all(): Values extends Record<string, any> ? Values : Record<string, any>;
 }
 //#endregion
-export { MASTRA_AUTH_TOKEN_KEY, MASTRA_INHERITED_MEMORY_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, VersionOverrides, VersionSelector, mergeVersionOverrides };
+export { MASTRA_AUTH_TOKEN_KEY, MASTRA_INHERITED_MEMORY_KEY, MASTRA_MESSAGE_AUTHOR_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, VersionOverrides, VersionSelector, mergeVersionOverrides };
 //# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_voice/dist/_types/zod/v3/ZodError.d.ts

@@ -10,13 +10,13 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
     too_big: "too_big";
     too_small: "too_small";
     not_multiple_of: "not_multiple_of";
     unrecognized_keys: "unrecognized_keys";
     invalid_union: "invalid_union";
+    custom: "custom";
     invalid_literal: "invalid_literal";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/checks.d.ts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/compat.d.ts

@@ -1,12 +1,11 @@
 import * as core from "../core/index.js";
 import type { ZodType } from "./schemas.js";
-export type { 
 /** @deprecated Use `z.output<T>` instead. */
-output as TypeOf, 
+export type TypeOf<T> = core.output<T>;
 /** @deprecated Use `z.output<T>` instead. */
-output as Infer, 
-/** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
-$ZodTypes as ZodFirstPartySchemaTypes, } from "../core/index.js";
+export type Infer<T> = core.output<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+export type ZodFirstPartySchemaTypes = core.$ZodTypes;
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 export declare const ZodIssueCode: {
     readonly invalid_type: "invalid_type";
@@ -21,9 +20,9 @@ export declare const ZodIssueCode: {
     readonly invalid_value: "invalid_value";
     readonly custom: "custom";
 };
-/** @deprecated Use `z.$ZodFlattenedError` */
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
-/** @deprecated Use `z.$ZodFormattedError` */
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;
 /** Use `z.$brand` instead */
 export type BRAND<T extends string | number | symbol = string | number | symbol> = {
@@ -36,13 +35,12 @@ export { $brand, config } from "../core/index.js";
 export declare function setErrorMap(map: core.$ZodErrorMap): void;
 /** @deprecated Use `z.config()` instead. */
 export declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
-export type { 
 /** @deprecated Use z.ZodType (without generics) instead. */
-ZodType as ZodTypeAny, 
+export type ZodTypeAny<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as ZodSchema, 
+export type ZodSchema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as Schema, };
+export type Schema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
 /** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/deep-partial.d.ts

@@ -0,0 +1,14 @@
+import type * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+/** Distributes `.partial()` through every object in a schema type, preserving the wrappers around them. */
+export type DeepPartial<T extends core.SomeType> = T extends schemas.ZodObject<infer Shape, infer Config> ? schemas.ZodObject<{
+    -readonly [K in keyof Shape]: schemas.ZodOptional<DeepPartial<Shape[K]>>;
+}, Config> : T extends schemas.ZodDiscriminatedUnion<infer Options, any> ? schemas.ZodUnion<{
+    -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I];
+}> : T extends schemas.ZodUnion<infer Options> ? schemas.ZodUnion<{
+    -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I];
+}> : T extends schemas.ZodArray<infer El> ? schemas.ZodArray<DeepPartial<El>> : T extends schemas.ZodTuple<infer Items, infer Rest> ? schemas.ZodTuple<{
+    -readonly [K in keyof Items]: Items[K] extends core.SomeType ? DeepPartial<Items[K]> : Items[K];
+}, Rest extends core.SomeType ? DeepPartial<Rest> : Rest> : T extends schemas.ZodIntersection<infer A, infer B> ? schemas.ZodIntersection<DeepPartial<A>, DeepPartial<B>> : T extends schemas.ZodRecord<infer K, infer V> ? schemas.ZodRecord<K, DeepPartial<V>> : T extends schemas.ZodMap<infer K, infer V> ? schemas.ZodMap<K, DeepPartial<V>> : T extends schemas.ZodSet<infer El> ? schemas.ZodSet<DeepPartial<El>> : T extends schemas.ZodOptional<infer Inner> ? schemas.ZodOptional<DeepPartial<Inner>> : T extends schemas.ZodNullable<infer Inner> ? schemas.ZodNullable<DeepPartial<Inner>> : T extends schemas.ZodDefault<infer Inner> ? schemas.ZodDefault<DeepPartial<Inner>> : T extends schemas.ZodPrefault<infer Inner> ? schemas.ZodPrefault<DeepPartial<Inner>> : T extends schemas.ZodNonOptional<infer Inner> ? schemas.ZodNonOptional<DeepPartial<Inner>> : T extends schemas.ZodCatch<infer Inner> ? schemas.ZodCatch<DeepPartial<Inner>> : T extends schemas.ZodReadonly<infer Inner> ? schemas.ZodReadonly<DeepPartial<Inner>> : T extends schemas.ZodSuccess<infer Inner> ? schemas.ZodSuccess<DeepPartial<Inner>> : T extends schemas.ZodPromise<infer Inner> ? schemas.ZodPromise<DeepPartial<Inner>> : T extends schemas.ZodCodec<infer A, infer B> ? schemas.ZodCodec<DeepPartial<A>, DeepPartial<B>> : T extends schemas.ZodPreprocess<infer B> ? schemas.ZodPreprocess<DeepPartial<B>> : T extends schemas.ZodPipe<infer A, infer B> ? schemas.ZodPipe<DeepPartial<A>, DeepPartial<B>> : T extends schemas.ZodLazy<infer Inner> ? schemas.ZodLazy<DeepPartial<Inner>> : T;
+/** Returns a copy of the schema with every nested object's properties made optional. */
+export declare function deepPartial<T extends core.SomeType>(schema: T): DeepPartial<T>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/errors.d.ts

@@ -19,12 +19,11 @@ export interface ZodError<T = unknown> extends $ZodError<T> {
 }
 export declare const ZodError: core.$constructor<ZodError>;
 export declare const ZodRealError: core.$constructor<ZodError>;
-export type { 
 /** @deprecated Use `z.core.$ZodFlattenedError` instead. */
-$ZodFlattenedError as ZodFlattenedError, 
+export type ZodFlattenedError<T, U = string> = core.$ZodFlattenedError<T, U>;
 /** @deprecated Use `z.core.$ZodFormattedError` instead. */
-$ZodFormattedError as ZodFormattedError, 
+export type ZodFormattedError<T, U = string> = core.$ZodFormattedError<T, U>;
 /** @deprecated Use `z.core.$ZodErrorMap` instead. */
-$ZodErrorMap as ZodErrorMap, } from "../core/index.js";
+export type ZodErrorMap<T extends core.$ZodIssueBase = core.$ZodIssue> = core.$ZodErrorMap<T>;
 /** @deprecated Use `z.core.$ZodRawIssue` instead. */
 export type IssueData = core.$ZodRawIssue;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/external.d.ts

@@ -4,11 +4,14 @@ export * from "./checks.js";
 export * from "./errors.js";
 export * from "./parse.js";
 export * from "./compat.js";
-export type { infer, output, input } from "../core/index.js";
+export type { infer } from "../core/index.js";
 export type { JSONType } from "../core/util.js";
-export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export type { CompileOptions } from "../core/index.js";
+export { globalRegistry, type GlobalMeta, registry, config, memoizer, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, INVALID, toZod, compile, withParser, ZodCompileAsyncError, ZodCompileUnsupportedError, getDiscriminatedOption, } from "../core/index.js";
 export { toJSONSchema } from "../core/json-schema-processors.js";
 export { fromJSONSchema } from "./from-json-schema.js";
+export { deepPartial } from "./deep-partial.js";
+export { input, output } from "./in-out.js";
 export * as locales from "../locales/index.js";
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
 export * as iso from "./iso.js";

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/in-out.d.ts

@@ -0,0 +1,8 @@
+import type * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+export declare function input<T extends core.$ZodType>(schema: T): schemas.ZodType<core.input<T>, core.input<T>>;
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+export declare function output<T extends core.$ZodType>(schema: T): schemas.ZodType<core.output<T>, core.output<T>>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/index.d.ts

@@ -1,4 +1,3 @@
 import * as z from "./external.js";
-export { z };
 export * from "./external.js";
-export default z;
+export { z, z as default };

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/iso.d.ts

@@ -1,22 +1,7 @@
 import * as core from "../core/index.js";
-import * as schemas from "./schemas.js";
-export interface ZodISODateTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateTimeInternals;
-}
-export declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
+import { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
 export declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;
-export interface ZodISODate extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateInternals;
-}
-export declare const ZodISODate: core.$constructor<ZodISODate>;
 export declare function date(params?: string | core.$ZodISODateParams): ZodISODate;
-export interface ZodISOTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISOTimeInternals;
-}
-export declare const ZodISOTime: core.$constructor<ZodISOTime>;
 export declare function time(params?: string | core.$ZodISOTimeParams): ZodISOTime;
-export interface ZodISODuration extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODurationInternals;
-}
-export declare const ZodISODuration: core.$constructor<ZodISODuration>;
 export declare function duration(params?: string | core.$ZodISODurationParams): ZodISODuration;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/parse.d.ts

@@ -21,10 +21,23 @@ export declare const parseAsync: <T extends core.$ZodType>(schema: T, value: unk
 }) => Promise<core.output<T>>;
 export declare const safeParse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
 export declare const safeParseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
-export declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;
-export declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;
-export declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;
-export declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;
+export { validate, validateAsync } from "../core/index.js";
+export declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => core.input<T>;
+export declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => core.output<T>;
+export declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => Promise<core.input<T>>;
+export declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => Promise<core.output<T>>;
 export declare const safeEncode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;
 export declare const safeDecode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
 export declare const safeEncodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/classic/schemas.d.ts

@@ -1,5 +1,6 @@
+import type { $ZodBigIntFormats } from "../core/checks.js";
 import * as core from "../core/index.js";
-import { util } from "../core/index.js";
+import { util, type $ZodNumberFormats } from "../core/index.js";
 import type { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
 import * as parse from "./parse.js";
 export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
@@ -27,6 +28,8 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
+    validate(data: unknown, params?: core.ParseContext<core.$ZodIssue>): data is core.input<this>;
+    validateAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<boolean>;
     encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
     decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
@@ -79,7 +82,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
      * ```
      */
     isNullable(): boolean;
-    apply<T>(fn: (schema: this) => T): T;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodType<any, any, Internals> {
 }
@@ -172,6 +175,22 @@ export declare function string<T extends string>(params?: string | core.$ZodStri
 export interface ZodStringFormat<Format extends string = string> extends _ZodString<core.$ZodStringFormatInternals<Format>> {
 }
 export declare const ZodStringFormat: core.$constructor<ZodStringFormat>;
+export interface ZodISODateTime extends ZodStringFormat {
+    _zod: core.$ZodISODateTimeInternals;
+}
+export declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
+export interface ZodISODate extends ZodStringFormat {
+    _zod: core.$ZodISODateInternals;
+}
+export declare const ZodISODate: core.$constructor<ZodISODate>;
+export interface ZodISOTime extends ZodStringFormat {
+    _zod: core.$ZodISOTimeInternals;
+}
+export declare const ZodISOTime: core.$constructor<ZodISOTime>;
+export interface ZodISODuration extends ZodStringFormat {
+    _zod: core.$ZodISODurationInternals;
+}
+export declare const ZodISODuration: core.$constructor<ZodISODuration>;
 export interface ZodEmail extends ZodStringFormat<"email"> {
     _zod: core.$ZodEmailInternals;
 }
@@ -288,6 +307,16 @@ export interface ZodE164 extends ZodStringFormat<"e164"> {
 }
 export declare const ZodE164: core.$constructor<ZodE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodE164;
+export interface ZodCreditCard extends ZodStringFormat<"credit_card"> {
+    _zod: core.$ZodCreditCardInternals;
+}
+export declare const ZodCreditCard: core.$constructor<ZodCreditCard>;
+export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodCreditCard;
+export interface ZodIBAN extends ZodStringFormat<"iban"> {
+    _zod: core.$ZodIBANInternals;
+}
+export declare const ZodIBAN: core.$constructor<ZodIBAN>;
+export declare function iban(params?: string | core.$ZodIBANParams): ZodIBAN;
 export interface ZodJWT extends ZodStringFormat<"jwt"> {
     _zod: core.$ZodJWTInternals;
 }
@@ -301,6 +330,7 @@ export declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFor
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
 export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
 export declare function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"currency_code">;
 export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
     enc?: Enc;
 } & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
@@ -338,23 +368,23 @@ export interface ZodNumber extends _ZodNumber<core.$ZodNumberInternals<number>>
 }
 export declare const ZodNumber: core.$constructor<ZodNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodNumber;
-export interface ZodNumberFormat extends ZodNumber {
-    _zod: core.$ZodNumberFormatInternals;
+export interface ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends ZodNumber {
+    _zod: core.$ZodNumberFormatInternals<Format>;
 }
 export declare const ZodNumberFormat: core.$constructor<ZodNumberFormat>;
-export interface ZodInt extends ZodNumberFormat {
+export interface ZodInt extends ZodNumberFormat<"safeint"> {
 }
 export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;
-export interface ZodFloat32 extends ZodNumberFormat {
+export interface ZodFloat32 extends ZodNumberFormat<"float32"> {
 }
 export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;
-export interface ZodFloat64 extends ZodNumberFormat {
+export interface ZodFloat64 extends ZodNumberFormat<"float64"> {
 }
 export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;
-export interface ZodInt32 extends ZodNumberFormat {
+export interface ZodInt32 extends ZodNumberFormat<"int32"> {
 }
 export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;
-export interface ZodUInt32 extends ZodNumberFormat {
+export interface ZodUInt32 extends ZodNumberFormat<"uint32"> {
 }
 export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
 export interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals> extends _ZodType<T> {
@@ -385,12 +415,16 @@ export interface ZodBigInt extends _ZodBigInt<core.$ZodBigIntInternals<bigint>>
 }
 export declare const ZodBigInt: core.$constructor<ZodBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;
-export interface ZodBigIntFormat extends ZodBigInt {
-    _zod: core.$ZodBigIntFormatInternals;
+export interface ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends ZodBigInt {
+    _zod: core.$ZodBigIntFormatInternals<Format>;
 }
 export declare const ZodBigIntFormat: core.$constructor<ZodBigIntFormat>;
-export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
-export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
+export interface ZodInt64 extends ZodBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodInt64;
+export interface ZodUInt64 extends ZodBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodUInt64;
 export interface ZodSymbol extends _ZodType<core.$ZodSymbolInternals> {
 }
 export declare const ZodSymbol: core.$constructor<ZodSymbol>;
@@ -479,6 +513,12 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
     partial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{
         -readonly [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
     }, Config>;
+    exactPartial(): ZodObject<{
+        -readonly [k in keyof Shape]: ZodExactOptional<Shape[k]>;
+    }, Config>;
+    exactPartial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{
+        -readonly [k in keyof Shape]: k extends keyof M ? ZodExactOptional<Shape[k]> : Shape[k];
+    }, Config>;
     required(): ZodObject<{
         -readonly [k in keyof Shape]: ZodNonOptional<Shape[k]>;
     }, Config>;
@@ -511,7 +551,7 @@ export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[]
     def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
@@ -520,6 +560,9 @@ export declare function intersection<T extends core.SomeType, U extends core.Som
 export interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null> extends _ZodType<core.$ZodTupleInternals<T, Rest>>, core.$ZodTuple<T, Rest> {
     "~standard": ZodStandardSchemaWithJSON<this>;
     rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;
+    partial(): ZodTuple<{
+        -readonly [k in keyof T]: ZodOptional<T[k]>;
+    }, Rest>;
 }
 export declare const ZodTuple: core.$constructor<ZodTuple>;
 export declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodTuple<T, null>;
@@ -674,10 +717,10 @@ export declare function codec<const A extends core.SomeType, B extends core.Some
     encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export declare function invertCodec<A extends core.SomeType, B extends core.SomeType>(codec: ZodCodec<A, B>): ZodCodec<B, A>;
-export interface ZodPreprocess<B extends core.SomeType = core.$ZodType> extends ZodPipe<core.$ZodTransform, B>, core.$ZodPreprocess<B> {
+export interface ZodPreprocess<B extends core.SomeType = core.$ZodType, I = unknown> extends ZodPipe<core.$ZodTransform<unknown, I>, B>, core.$ZodPreprocess<B, I> {
     "~standard": ZodStandardSchemaWithJSON<this>;
-    _zod: core.$ZodPreprocessInternals<B>;
-    def: core.$ZodPreprocessDef<B>;
+    _zod: core.$ZodPreprocessInternals<B, I>;
+    def: core.$ZodPreprocessDef<B, I>;
 }
 export declare const ZodPreprocess: core.$constructor<ZodPreprocess>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
@@ -744,7 +787,13 @@ export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx
 export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
-declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
+export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
+    properties<Shape extends {
+        [k in keyof T as T[k] extends Function ? never : k]?: core.$ZodType<unknown, T[k]>;
+    }>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+}
+export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
+declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;
 export { _instanceof as instanceof };
 export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
 type _ZodJSONSchema = ZodUnion<[
@@ -764,4 +813,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPreprocess<U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPreprocess<U, B>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/core/api.d.ts

@@ -17,7 +17,9 @@ AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = P
 export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
 export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
 export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
-export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
+export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce"> & {
+    checks?: readonly checks.$ZodCheck<string>[];
+};
 export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
 export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
 export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
@@ -46,8 +48,8 @@ export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<
 export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
 export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
 export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
-export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
-export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
+export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
+export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
 export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
 /**
  * @deprecated CUID v1 is deprecated by its authors due to information leakage
@@ -103,6 +105,12 @@ export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.
 export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
 export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
 export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
+export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+export declare function _creditCard<T extends schemas.$ZodCreditCard>(Class: util.SchemaClass<T>, params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams): T;
+export type $ZodIBANParams = StringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+export type $ZodCheckIBANParams = CheckStringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+export declare function _iban<T extends schemas.$ZodIBAN>(Class: util.SchemaClass<T>, params?: string | $ZodIBANParams | $ZodCheckIBANParams): T;
 export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
 export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
 export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
@@ -125,7 +133,9 @@ export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.Sche
 export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
 export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
 export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
-export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
+export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce"> & {
+    checks?: readonly checks.$ZodCheck<number>[];
+};
 export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
 export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
 export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
@@ -208,8 +218,10 @@ export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suf
 export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
 export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
 export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
-    [k in K]: core.output<T>;
+    [k in K]: util.Widen<core.input<T>>;
 }>;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
+export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): checks.$ZodCheckProperties<Shape>;
 export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
 export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
 export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
@@ -225,22 +237,20 @@ export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
 export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
 export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
 export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
-export interface $ZodTypeDiscriminableInternals<Disc extends string = string> extends schemas.$ZodTypeInternals<unknown, {
-    [K in Disc]?: unknown;
-}> {
+export interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$ZodTypeInternals {
     propValues: util.PropValues;
 }
-export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
-    _zod: $ZodTypeDiscriminableInternals<Disc>;
+export interface $ZodTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
+    _zod: $ZodTypeDiscriminableInternals;
 }
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
-export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
+export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
 export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
 export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
 export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
 export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
 export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
-export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
+export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType" | "partial">;
 export declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
 export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
 export declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;

package/dist/_types/@internal_voice/dist/_types/zod/v4/core/checks.d.ts

@@ -60,29 +60,29 @@ export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint
 }
 export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
 export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
-export interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
+export interface $ZodCheckNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
     check: "number_format";
-    format: $ZodNumberFormats;
+    format: Format;
 }
-export interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
-    def: $ZodCheckNumberFormatDef;
+export interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
+    def: $ZodCheckNumberFormatDef<Format>;
     issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
 }
-export interface $ZodCheckNumberFormat extends $ZodCheck<number> {
-    _zod: $ZodCheckNumberFormatInternals;
+export interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
+    _zod: $ZodCheckNumberFormatInternals<Format>;
 }
 export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
 export type $ZodBigIntFormats = "int64" | "uint64";
-export interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {
+export interface $ZodCheckBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckDef {
     check: "bigint_format";
-    format: $ZodBigIntFormats | undefined;
+    format: Format;
 }
-export interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {
-    def: $ZodCheckBigIntFormatDef;
+export interface $ZodCheckBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckInternals<bigint> {
+    def: $ZodCheckBigIntFormatDef<Format>;
     issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
 }
-export interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {
-    _zod: $ZodCheckBigIntFormatInternals;
+export interface $ZodCheckBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheck<bigint> {
+    _zod: $ZodCheckBigIntFormatInternals<Format>;
 }
 export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
 export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
@@ -157,7 +157,7 @@ export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength
     _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 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" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
 export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
     check: "string_format";
     format: Format;
@@ -250,6 +250,22 @@ export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<
     _zod: $ZodCheckPropertyInternals<T>;
 }
 export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
+export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
+    check: "properties";
+    shape: Shape;
+}
+export type $ZodCheckPropertiesInput<Shape extends schemas.$ZodShape = schemas.$ZodShape> = {
+    -readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>>;
+};
+export interface $ZodCheckPropertiesInternals<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
+    def: $ZodCheckPropertiesDef<Shape>;
+    issc: errors.$ZodIssue;
+}
+export interface $ZodCheckProperties<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
+    _zod: $ZodCheckPropertiesInternals<Shape>;
+    [Symbol.iterator](): Iterator<this>;
+}
+export declare const $ZodCheckProperties: core.$constructor<$ZodCheckProperties>;
 export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
     check: "mime_type";
     mime: util.MimeTypes[];