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

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

@@ -0,0 +1,65 @@
+import type * as core from "./core.js";
+import type { SomeType } from "./schemas.js";
+/** @internal Sentinel the compiled fast path returns when validation fails. */
+export declare const INVALID: unique symbol;
+/** @internal */
+export type INVALID = typeof INVALID;
+interface CompileFnOptions {
+    debug?: boolean | undefined;
+    /** Emit a validator instead of a parser: skip building the output value where nothing reads it. */
+    assertOnly?: boolean | undefined;
+}
+type CompiledFn<T> = ((input: unknown) => T | INVALID) & {
+    code?: string | undefined;
+    /** False when this function's INVALID does not strictly mean "the runtime would reject". */
+    definite?: boolean | undefined;
+};
+/** Raised when the schema contains async refinements or transforms. Surfaces only under `compile(schema, { strict: true })`. */
+export declare class ZodCompileAsyncError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Raised when the schema contains a feature whose semantics the fast path
+ * can't fully model. Both the shim in `zod/compile` and the default
+ * `compile()` fall back to the runtime parser for that schema; only
+ * `compile(schema, { strict: true })` lets it surface.
+ */
+export declare class ZodCompileUnsupportedError extends Error {
+    /** Whether a container may absorb this refusal by running the child through the runtime (see `compileChild`). False when running only that node on the runtime is not equivalent to running the whole parse there — a runtime island gets no parse context, so a node that *consumes* issues rather than propagating them would finalize them against the wrong error map and still succeed. */
+    readonly islandable: boolean;
+    constructor(feature: string, islandable?: boolean);
+}
+export interface CompileOptions {
+    /** Throw the refusal instead of returning the schema uncompiled. */
+    strict?: boolean | undefined;
+}
+/**
+ * AOT-compile a Zod schema. Returns a clone whose `_zod.run` calls a generated
+ * fast path first and falls back to the original runtime parser on failure.
+ *
+ * - Forward direction only. Backward (encode), async, and `skipChecks` paths
+ *   bypass the fast path and use the runtime directly.
+ * - Never throws. A schema the fast path can't model is returned unchanged and
+ *   keeps using the runtime parser. Pass `{ strict: true }` to get the refusal
+ *   as a thrown `ZodCompileUnsupportedError` / `ZodCompileAsyncError` instead.
+ * - The original schema is unchanged. The clone shares children by reference.
+ */
+export declare function compile<T extends SomeType>(schema: T, options?: CompileOptions): T;
+/**
+ * Install an already-generated parser as a schema's fast path. Returns a clone; the original is
+ * unchanged.
+ *
+ * The parser takes the input and returns the parsed value, or `INVALID` to hand the parse to the
+ * runtime. It must be synchronous and forward-direction, and it must build fresh output rather than
+ * return its input — Zod cannot check either, and a wrong *success* is returned to the caller as-is.
+ *
+ * `compile()` is the ordinary entry point. This is for a build-time or native compiler that produces
+ * a parser where `new Function` is unavailable.
+ */
+export declare function withParser<T extends SomeType>(schema: T, parser: (input: unknown) => core.output<T> | INVALID): T;
+/**
+ * @internal Generate the standalone compiled function: a parser by default, a validator under
+ * `assertOnly`. Returns the parsed value, `true` where nothing reads the output, or `INVALID`. Consumers use `compile()`.
+ */
+export declare function compileFn<T extends SomeType>(schema: T, options?: CompileFnOptions): CompiledFn<core.output<T>>;
+export {};

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

@@ -1,6 +1,6 @@
 import type * as errors from "./errors.js";
 import type * as schemas from "./schemas.js";
-import type { Class } from "./util.js";
+import type { Class, ProtoOf } from "./util.js";
 type ZodTrait = {
     _zod: {
         def: any;
@@ -11,11 +11,14 @@ export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
     new (def: D): T;
     init(inst: T, def: D): asserts inst is T;
 }
+export interface $constructorParams {
+    Parent?: typeof Class;
+}
 /** 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 function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, 
+/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
+proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
 export declare const $brand: unique symbol;
 export type $brand<T extends string | number | symbol = string | number | symbol> = {
     [$brand]: {
@@ -65,6 +68,15 @@ export interface $ZodConfig {
     localeError?: errors.$ZodErrorMap | undefined;
     /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
     jitless?: boolean | undefined;
+    /** Enables parsing input that contains reference cycles. Read when a schema is constructed. */
+    memoizer?: schemas.$ZodMemoizer | undefined;
+    /**
+     * Internal: post-processor invoked on every freshly-constructed schema
+     * instance, after init and deferred fns run. Set by `import "zod/compile"`
+     * to install AOT compilation. Not part of the public API.
+     * @internal
+     */
+    postProcessor?: ((inst: any) => void) | undefined;
 }
 export declare const globalConfig: $ZodConfig;
 export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;

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

@@ -3,9 +3,11 @@ type ModeWriter = (doc: Doc, modes: {
 }) => void;
 export declare class Doc {
     args: string[];
+    /** Bindings the compiled function closes over, by name. */
+    closed: Record<string, unknown>;
     content: string[];
     indent: number;
-    constructor(args?: string[]);
+    constructor(args?: string[], closed?: Record<string, unknown>);
     indented(fn: (doc: Doc) => void): void;
     write(fn: ModeWriter): void;
     write(line: string): void;

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

@@ -63,6 +63,8 @@ interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
     readonly input?: unknown;
     readonly discriminator?: string | undefined;
     readonly inclusive: false;
+    /** Indices of the options that matched */
+    readonly matches: number[];
 }
 export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
@@ -120,6 +122,8 @@ type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakeP
     readonly input: unknown;
     /** The schema or check that originated this issue. */
     readonly inst?: $ZodType | $ZodCheck;
+    /** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
+    readonly schema?: $ZodType | undefined;
     /** If `true`, Zod will continue executing checks/refinements after this issue. */
     readonly continue?: boolean | undefined;
 } & Record<string, unknown>> : never;

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

@@ -2,13 +2,16 @@ export * from "./core.js";
 export * from "./parse.js";
 export * from "./errors.js";
 export * from "./schemas.js";
+export * from "./memoizer.js";
 export * from "./checks.js";
 export * from "./versions.js";
 export * as util from "./util.js";
+export { toZod } from "./util.js";
 export * as regexes from "./regexes.js";
 export * as locales from "../locales/index.js";
 export * from "./registries.js";
 export * from "./doc.js";
+export * from "./compile.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
 export { toJSONSchema } from "./json-schema-processors.js";

package/dist/_types/@internal_voice/dist/_types/zod/v4/core/json-schema-generator.d.ts

@@ -1,7 +1,7 @@
 import type * as JSONSchema from "./json-schema.js";
 import type { $ZodRegistry } from "./registries.js";
 import type * as schemas from "./schemas.js";
-import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen } from "./to-json-schema.js";
+import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen, type ToJSONSchemaContext } from "./to-json-schema.js";
 /**
  * Parameters for the emit method of JSONSchemaGenerator.
  * @deprecated Use toJSONSchema function instead
@@ -36,7 +36,7 @@ export declare class JSONSchemaGenerator {
     /** @deprecated Access via ctx instead */
     get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
     /** @deprecated Access via ctx instead */
-    get unrepresentable(): "any" | "throw";
+    get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
     /** @deprecated Access via ctx instead */
     get override(): (ctx: {
         zodSchema: schemas.$ZodType;

package/dist/_types/@internal_voice/dist/_types/zod/v4/core/json-schema-processors.d.ts

@@ -1,6 +1,21 @@
 import type { $ZodRegistry } from "./registries.js";
 import type * as schemas from "./schemas.js";
 import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.js";
+type Bound = number | bigint | Date;
+interface CheckAggregate<N extends Bound = Bound> {
+    minimum?: N;
+    maximum?: N;
+    exclusiveMinimum?: N;
+    exclusiveMaximum?: N;
+    multipleOf?: number[];
+    format?: string;
+    isInt?: boolean;
+    patterns?: Set<RegExp>;
+    mime?: string[];
+    contentEncoding?: string;
+    laxFormat?: boolean;
+}
+export declare function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N>;
 export declare const stringProcessor: Processor<schemas.$ZodString>;
 export declare const numberProcessor: Processor<schemas.$ZodNumber>;
 export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
@@ -47,3 +62,4 @@ export declare function toJSONSchema(registry: $ZodRegistry<{
 }>, params?: RegistryToJSONSchemaParams): {
     schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
 };
+export {};

package/dist/_types/@internal_voice/dist/_types/zod/v4/core/json-schema.d.ts

@@ -1,5 +1,6 @@
 export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
 export type _JSONSchema = boolean | JSONSchema;
+export type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
 export type JSONSchema = {
     [k: string]: unknown;
     $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
@@ -11,7 +12,7 @@ export type JSONSchema = {
     $vocabulary?: Record<string, boolean>;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
-    type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+    type?: SchemaType | SchemaType[];
     additionalItems?: _JSONSchema;
     unevaluatedItems?: _JSONSchema;
     prefixItems?: _JSONSchema[];

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

@@ -0,0 +1,15 @@
+import type { $ZodMemoizer, $ZodType } from "./schemas.js";
+export declare class $ZodCyclicError extends Error {
+    constructor();
+}
+/**
+ * Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
+ * Exported for `z.compile`, which refuses to compile such a schema: cycle
+ * breaking is driven from here off state keyed on the parse context, and a
+ * generated fast path has no context to key on.
+ */
+export declare function isRecursiveSchema(inst: $ZodType): boolean;
+/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
+export declare function memoizer(): $ZodMemoizer;
+/** Whether this value is a node a back-edge resolved to before it finished. */
+export declare function isBackEdge(ctx: object, value: unknown): boolean;

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

@@ -5,16 +5,14 @@ import * as util from "./util.js";
 export type $ZodErrorClass = {
     new (issues: errors.$ZodIssue[]): errors.$ZodError;
 };
-export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
+type $ParseParams = {
     callee?: util.AnyFunc;
-    Err?: $ZodErrorClass;
-}) => core.output<T>;
+    Err?: $ZodErrorClass | undefined;
+};
+export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
 export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
 export declare const parse: $Parse;
-export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
-    callee?: util.AnyFunc;
-    Err?: $ZodErrorClass;
-}) => Promise<core.output<T>>;
+export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
 export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
 export declare const parseAsync: $ParseAsync;
 export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
@@ -23,16 +21,20 @@ export declare const safeParse: $SafeParse;
 export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
 export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
 export declare const safeParseAsync: $SafeParseAsync;
-export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;
+export type $Validate = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => value is core.input<T>;
+export declare const validate: $Validate;
+export type $ValidateAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<boolean>;
+export declare const validateAsync: $ValidateAsync;
+export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.input<T>;
 export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
 export declare const encode: $Encode;
-export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;
+export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
 export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
 export declare const decode: $Decode;
-export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;
+export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.input<T>>;
 export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
 export declare const encodeAsync: $EncodeAsync;
-export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;
+export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
 export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
 export declare const decodeAsync: $DecodeAsync;
 export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
@@ -47,3 +49,4 @@ export declare const safeEncodeAsync: $SafeEncodeAsync;
 export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
 export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
 export declare const safeDecodeAsync: $SafeDecodeAsync;
+export {};

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

@@ -9,6 +9,7 @@ export declare const ulid: RegExp;
 export declare const xid: RegExp;
 export declare const ksuid: RegExp;
 export declare const nanoid: RegExp;
+export declare function nanoidOfLength(length: number): RegExp;
 /** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
 export declare const duration: RegExp;
 /** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
@@ -44,6 +45,9 @@ export declare const hostname: RegExp;
 export declare const domain: RegExp;
 export declare const httpProtocol: RegExp;
 export declare const e164: RegExp;
+export declare const creditCard: RegExp;
+export declare const currencyCode: RegExp;
+export declare const iban: RegExp;
 export declare const date: RegExp;
 export declare function time(args: {
     precision?: number | null;
@@ -53,6 +57,7 @@ export declare function datetime(args: {
     offset?: boolean;
     local?: boolean;
 }): RegExp;
+export declare const anyString: RegExp;
 export declare const string: (params?: {
     minimum?: number | undefined;
     maximum?: number | undefined;