@mastra/voice-speechify 0.12.0 → 0.12.1-alpha.0

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/base/index.d.ts

@@ -0,0 +1,31 @@
+import { RegisteredLogger, IMastraLogger } from '../logger/index.js';
+import 'node:stream';
+
+declare class MastraBase {
+    #private;
+    component: RegisteredLogger;
+    protected logger: IMastraLogger;
+    name?: string;
+    constructor({ component, name, rawConfig, }: {
+        component?: RegisteredLogger;
+        name?: string;
+        rawConfig?: Record<string, unknown>;
+    });
+    /**
+     * Returns the raw storage configuration this primitive was created from,
+     * or undefined if it was created from code.
+     */
+    toRawConfig(): Record<string, unknown> | undefined;
+    /**
+     * Sets the raw storage configuration for this primitive.
+     * @internal
+     */
+    __setRawConfig(rawConfig: Record<string, unknown>): void;
+    /**
+     * Set the logger for the agent
+     * @param logger
+     */
+    __setLogger(logger: IMastraLogger): void;
+}
+
+export { MastraBase };

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/logger/index.d.ts

@@ -0,0 +1,217 @@
+import { Transform } from 'node:stream';
+
+declare const RegisteredLogger: {
+    readonly AGENT: "AGENT";
+    readonly OBSERVABILITY: "OBSERVABILITY";
+    readonly AUTH: "AUTH";
+    readonly BROWSER: "BROWSER";
+    readonly NETWORK: "NETWORK";
+    readonly WORKFLOW: "WORKFLOW";
+    readonly LLM: "LLM";
+    readonly TTS: "TTS";
+    readonly VOICE: "VOICE";
+    readonly VECTOR: "VECTOR";
+    readonly BUNDLER: "BUNDLER";
+    readonly DEPLOYER: "DEPLOYER";
+    readonly MEMORY: "MEMORY";
+    readonly STORAGE: "STORAGE";
+    readonly EMBEDDINGS: "EMBEDDINGS";
+    readonly MCP_SERVER: "MCP_SERVER";
+    readonly SERVER_CACHE: "SERVER_CACHE";
+    readonly SERVER: "SERVER";
+    readonly WORKSPACE: "WORKSPACE";
+    readonly CHANNEL: "CHANNEL";
+};
+type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
+declare const LogLevel: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+    readonly NONE: "silent";
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+interface BaseLogMessage {
+    runId?: string;
+    msg: string;
+    level: LogLevel;
+    time: Date;
+    pid: number;
+    hostname: string;
+    name: string;
+}
+declare abstract class LoggerTransport extends Transform {
+    constructor(opts?: any);
+    listLogsByRunId(_args: {
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    listLogs(_args?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        returnPaginationResults?: boolean;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+}
+declare const createCustomTransport: (stream: Transform, listLogs?: LoggerTransport["listLogs"], listLogsByRunId?: LoggerTransport["listLogsByRunId"]) => LoggerTransport;
+interface IMastraLogger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    trackException(error: Error, metadata?: Record<string, unknown>): void;
+    getTransports(): Map<string, LoggerTransport>;
+    listLogs(_transportId: string, _params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    listLogsByRunId(_args: {
+        transportId: string;
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+}
+declare abstract class MastraLogger implements IMastraLogger {
+    protected name: string;
+    protected level: LogLevel;
+    protected transports: Map<string, LoggerTransport>;
+    constructor(options?: {
+        name?: string;
+        level?: LogLevel;
+        transports?: Record<string, LoggerTransport>;
+    });
+    abstract debug(message: string, ...args: any[]): void;
+    abstract info(message: string, ...args: any[]): void;
+    abstract warn(message: string, ...args: any[]): void;
+    abstract error(message: string, ...args: any[]): void;
+    getTransports(): Map<string, LoggerTransport>;
+    trackException(_error: Error, _metadata?: Record<string, unknown>): void;
+    listLogs(transportId: string, params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    listLogsByRunId({ transportId, runId, fromDate, toDate, logLevel, filters, page, perPage, }: {
+        transportId: string;
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+}
+type LogFilterContext = {
+    component?: RegisteredLogger;
+    level: LogLevel;
+    message: string;
+    args: unknown[];
+};
+type LogFilter = (ctx: LogFilterContext) => boolean;
+interface ConsoleLoggerOptions {
+    name?: string;
+    level?: LogLevel;
+    component?: RegisteredLogger;
+    filter?: LogFilter;
+}
+declare class ConsoleLogger extends MastraLogger {
+    protected component?: RegisteredLogger;
+    protected filter?: LogFilter;
+    constructor(options?: ConsoleLoggerOptions);
+    child(componentOrBindings: RegisteredLogger | Record<string, unknown>): ConsoleLogger;
+    private shouldLog;
+    private prefix;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    listLogs(_transportId: string, _params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: never[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    listLogsByRunId(_args: {
+        transportId: string;
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: never[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+}
+
+export { type BaseLogMessage, ConsoleLogger, type ConsoleLoggerOptions, type IMastraLogger, type LogFilter, type LogFilterContext, LogLevel, LoggerTransport, MastraLogger, RegisteredLogger, createCustomTransport };

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

@@ -0,0 +1,147 @@
+type RecordToTuple<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+/**
+ * Reserved key for setting resourceId from middleware.
+ * When set in RequestContext, this takes precedence over client-provided values
+ * for security (prevents attackers from hijacking another user's memory).
+ *
+ * @example
+ * ```typescript
+ * // In your auth middleware:
+ * const requestContext = c.get('requestContext');
+ * requestContext.set(MASTRA_RESOURCE_ID_KEY, authenticatedUser.id);
+ * ```
+ */
+declare const MASTRA_RESOURCE_ID_KEY = "mastra__resourceId";
+/**
+ * Reserved key for setting threadId from middleware.
+ * When set in RequestContext, this takes precedence over client-provided values
+ * for security (prevents attackers from hijacking another user's memory).
+ *
+ * @example
+ * ```typescript
+ * // In your auth middleware:
+ * const requestContext = c.get('requestContext');
+ * requestContext.set(MASTRA_THREAD_ID_KEY, threadId);
+ * ```
+ */
+declare const MASTRA_THREAD_ID_KEY = "mastra__threadId";
+/**
+ * Reserved key for storing version overrides on RequestContext.
+ * When set, sub-agent delegation resolves versioned agents from these overrides.
+ *
+ * @example
+ * ```typescript
+ * requestContext.set(MASTRA_VERSIONS_KEY, {
+ *   agents: { 'researcher-agent': { versionId: '123' } },
+ * });
+ * ```
+ */
+declare const MASTRA_VERSIONS_KEY = "mastra__versions";
+/**
+ * Reserved key for storing the raw auth token from the incoming request.
+ * Used by the editor to forward authentication when connecting to MCP servers
+ * that require the same auth as the Mastra server itself.
+ */
+declare const MASTRA_AUTH_TOKEN_KEY = "mastra__authToken";
+type VersionSelector = {
+    versionId: string;
+} | {
+    status: 'draft' | 'published';
+};
+type VersionOverrides = {
+    agents?: Record<string, VersionSelector>;
+    /** Fallback status for sub-agents (and future primitives) without an explicit entry. */
+    defaultStatus?: 'draft' | 'published';
+};
+declare function mergeVersionOverrides(base?: VersionOverrides, overrides?: VersionOverrides): VersionOverrides | undefined;
+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]>);
+    /**
+     * set a value with strict typing if `Values` is a Record and the key exists in it.
+     */
+    set<K extends Values extends Record<string, any> ? keyof Values : string>(key: K, value: Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown): void;
+    /**
+     * Get a value with its type
+     */
+    get<K extends Values extends Record<string, any> ? keyof Values : string, R = Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown>(key: K): R;
+    /**
+     * Check if a key exists in the container
+     */
+    has<K extends Values extends Record<string, any> ? keyof Values : string>(key: K): boolean;
+    /**
+     * Delete a value by key
+     */
+    delete<K extends Values extends Record<string, any> ? keyof Values : string>(key: K): boolean;
+    /**
+     * Clear all values from the container
+     */
+    clear(): void;
+    /**
+     * Get all keys in the container
+     */
+    keys(): IterableIterator<Values extends Record<string, any> ? keyof Values : string>;
+    /**
+     * Get all values in the container
+     */
+    values(): IterableIterator<Values extends Record<string, any> ? Values[keyof Values] : unknown>;
+    /**
+     * Get all entries in the container.
+     * Returns a discriminated union of tuples for proper type narrowing when iterating.
+     */
+    entries(): IterableIterator<Values extends Record<string, any> ? {
+        [K in keyof Values]: [K, Values[K]];
+    }[keyof Values] : [string, unknown]>;
+    /**
+     * Get the size of the container
+     */
+    size(): number;
+    /**
+     * Execute a function for each entry in the container.
+     * The callback receives properly typed key-value pairs.
+     */
+    forEach<K extends Values extends Record<string, any> ? keyof Values : string>(callbackfn: (value: Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : unknown) : unknown, key: K, map: Map<string, unknown>) => void): void;
+    /**
+     * Custom JSON serialization method.
+     * Converts the internal Map to a plain object for proper JSON serialization.
+     * Non-serializable values (functions, symbols, RPC proxies, in-value
+     * circular references, and values whose serialization re-enters this
+     * `toJSON` via cross-context back-references) are skipped to prevent
+     * serialization errors when storing to database.
+     *
+     * Reentry safety: if a stored value's `isSerializable` probe re-enters
+     * `toJSON()` on this same instance (through a chain of RequestContexts
+     * holding references to each other), we throw `CyclicRequestContextToJSONError`.
+     * Inner `isSerializable` calls re-throw the marker; the outermost
+     * `isSerializable` swallows it and filters the offending key, the same
+     * way it filters in-value circular references today.
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Check if a value can be safely serialized to JSON.
+     *
+     * Re-throws `CyclicRequestContextToJSONError` when called from a nested
+     * `toJSON()` (`_toJSONDepth > 1`), so the marker propagates up to the
+     * outermost `toJSON()`'s `isSerializable`, which then swallows it and
+     * filters the offending key. This is what lets the outermost call return
+     * a clean JSON-safe dict for cross-context cycles.
+     */
+    private isSerializable;
+    /**
+     * Get all values as a typed object for destructuring.
+     * Returns Record<string, any> when untyped, or the Values type when typed.
+     *
+     * @example
+     * ```typescript
+     * const ctx = new RequestContext<{ userId: string; apiKey: string }>();
+     * ctx.set('userId', 'user-123');
+     * ctx.set('apiKey', 'key-456');
+     * const { userId, apiKey } = ctx.all;
+     * ```
+     */
+    get all(): Values extends Record<string, any> ? Values : Record<string, any>;
+}
+
+export { MASTRA_AUTH_TOKEN_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, type VersionOverrides, type VersionSelector, mergeVersionOverrides };

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+type ToolsInput = Record<string, any>;
+
+export type { ToolsInput };

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

@@ -0,0 +1,164 @@
+import type { Primitive } from "./helpers/typeAliases.js";
+import { util, type ZodParsedType } from "./helpers/util.js";
+import type { TypeOf, ZodType } from "./index.js";
+type allKeys<T> = T extends any ? keyof T : never;
+export type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export type typeToFlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<T>]?: U[];
+    };
+};
+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";
+    invalid_literal: "invalid_literal";
+    invalid_union_discriminator: "invalid_union_discriminator";
+    invalid_enum_value: "invalid_enum_value";
+    invalid_arguments: "invalid_arguments";
+    invalid_return_type: "invalid_return_type";
+    invalid_date: "invalid_date";
+    invalid_string: "invalid_string";
+    invalid_intersection_types: "invalid_intersection_types";
+    not_finite: "not_finite";
+};
+export type ZodIssueCode = keyof typeof ZodIssueCode;
+export type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string | undefined;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+export type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+    includes: string;
+    position?: number | undefined;
+} | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number | bigint;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+export type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+export type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean | undefined;
+    message: string;
+};
+export declare const quotelessJson: (obj: any) => string;
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? {
+    [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown;
+export type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+export type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+export declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format(): ZodFormattedError<T>;
+    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    static assert(value: unknown): asserts value is ZodError;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten(): typeToFlattenedError<T>;
+    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+    get formErrors(): typeToFlattenedError<T, string>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean | undefined;
+};
+export type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+export type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import type { ZodErrorMap } from "./ZodError.js";
+import defaultErrorMap from "./locales/en.js";
+export { defaultErrorMap };
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): ZodErrorMap;

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

@@ -0,0 +1,6 @@
+export * from "./errors.js";
+export * from "./helpers/parseUtil.js";
+export * from "./helpers/typeAliases.js";
+export * from "./helpers/util.js";
+export * from "./types.js";
+export * from "./ZodError.js";

package/dist/_types/@internal_voice/dist/_types/zod/v3/helpers/enumUtil.d.ts

@@ -0,0 +1,8 @@
+export declare namespace enumUtil {
+    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
+    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+    export {};
+}

package/dist/_types/@internal_voice/dist/_types/zod/v3/helpers/errorUtil.d.ts

@@ -0,0 +1,9 @@
+export declare namespace errorUtil {
+    type ErrMessage = string | {
+        message?: string | undefined;
+    };
+    const errToObj: (message?: ErrMessage) => {
+        message?: string | undefined;
+    };
+    const toString: (message?: ErrMessage) => string | undefined;
+}

package/dist/_types/@internal_voice/dist/_types/zod/v3/helpers/parseUtil.d.ts

@@ -0,0 +1,78 @@
+import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError.js";
+import type { ZodParsedType } from "./util.js";
+export declare const makeIssue: (params: {
+    data: any;
+    path: (string | number)[];
+    errorMaps: ZodErrorMap[];
+    issueData: IssueData;
+}) => ZodIssue;
+export type ParseParams = {
+    path: (string | number)[];
+    errorMap: ZodErrorMap;
+    async: boolean;
+};
+export type ParsePathComponent = string | number;
+export type ParsePath = ParsePathComponent[];
+export declare const EMPTY_PATH: ParsePath;
+export interface ParseContext {
+    readonly common: {
+        readonly issues: ZodIssue[];
+        readonly contextualErrorMap?: ZodErrorMap | undefined;
+        readonly async: boolean;
+    };
+    readonly path: ParsePath;
+    readonly schemaErrorMap?: ZodErrorMap | undefined;
+    readonly parent: ParseContext | null;
+    readonly data: any;
+    readonly parsedType: ZodParsedType;
+}
+export type ParseInput = {
+    data: any;
+    path: (string | number)[];
+    parent: ParseContext;
+};
+export declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+export type ObjectPair = {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+};
+export declare class ParseStatus {
+    value: "aborted" | "dirty" | "valid";
+    dirty(): void;
+    abort(): void;
+    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+    static mergeObjectAsync(status: ParseStatus, pairs: {
+        key: ParseReturnType<any>;
+        value: ParseReturnType<any>;
+    }[]): Promise<SyncParseReturnType<any>>;
+    static mergeObjectSync(status: ParseStatus, pairs: {
+        key: SyncParseReturnType<any>;
+        value: SyncParseReturnType<any>;
+        alwaysSet?: boolean;
+    }[]): SyncParseReturnType;
+}
+export interface ParseResult {
+    status: "aborted" | "dirty" | "valid";
+    data: any;
+}
+export type INVALID = {
+    status: "aborted";
+};
+export declare const INVALID: INVALID;
+export type DIRTY<T> = {
+    status: "dirty";
+    value: T;
+};
+export declare const DIRTY: <T>(value: T) => DIRTY<T>;
+export type OK<T> = {
+    status: "valid";
+    value: T;
+};
+export declare const OK: <T>(value: T) => OK<T>;
+export type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+export type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+export type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+export declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+export declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+export declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
+export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;

package/dist/_types/@internal_voice/dist/_types/zod/v3/helpers/partialUtil.d.ts

@@ -0,0 +1,8 @@
+import type { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodTuple, ZodTupleItems, ZodTypeAny } from "../types.js";
+export declare namespace partialUtil {
+    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
+        [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
+    }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
+        [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
+    } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}