@absolutejs/voice 0.0.22-beta.35 → 0.0.22-beta.350

package/dist/providerDecisionTraces.d.ts

@@ -0,0 +1,130 @@
+import { Elysia } from 'elysia';
+import { type VoiceRoutingEventKind } from './resilienceRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderDecisionStatus = 'degraded' | 'error' | 'fallback' | 'selected' | 'skipped' | 'success';
+export type VoiceProviderDecisionTrace = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind?: VoiceRoutingEventKind;
+    latencyBudgetMs?: number;
+    provider: string;
+    reason: string;
+    scenarioId?: string;
+    selectedProvider?: string;
+    sessionId: string;
+    status: VoiceProviderDecisionStatus;
+    surface: string;
+    turnId?: string;
+};
+export type VoiceProviderDecisionTraceInput = Omit<VoiceProviderDecisionTrace, 'at' | 'reason' | 'sessionId' | 'surface'> & {
+    at?: number;
+    reason?: string;
+    sessionId?: string;
+    surface?: string;
+};
+export type VoiceProviderDecisionTraceIssue = {
+    code: string;
+    message: string;
+    status: 'fail' | 'warn';
+    surface?: string;
+};
+export type VoiceProviderDecisionSurfaceReport = {
+    degraded: number;
+    decisions: number;
+    errors: number;
+    fallbacks: number;
+    issues: VoiceProviderDecisionTraceIssue[];
+    latestAt?: number;
+    providers: string[];
+    reasons: string[];
+    selected: number;
+    status: 'fail' | 'pass' | 'warn';
+    surface: string;
+};
+export type VoiceProviderDecisionTraceReport = {
+    checkedAt: number;
+    decisions: VoiceProviderDecisionTrace[];
+    issues: VoiceProviderDecisionTraceIssue[];
+    status: 'fail' | 'pass' | 'warn';
+    summary: {
+        degraded: number;
+        decisions: number;
+        errors: number;
+        fallbacks: number;
+        providers: number;
+        selected: number;
+        surfaces: number;
+    };
+    surfaces: VoiceProviderDecisionSurfaceReport[];
+};
+export type VoiceProviderDecisionTraceReportOptions = {
+    events?: StoredVoiceTraceEvent[] | VoiceProviderDecisionTrace[];
+    maxAgeMs?: number;
+    minDegraded?: number;
+    minDecisions?: number;
+    minFallbacks?: number;
+    now?: number;
+    requiredFallbackProviders?: readonly string[];
+    requiredProviders?: readonly string[];
+    requiredReasonIncludes?: readonly string[];
+    requiredSurfaces?: readonly string[];
+    requiredStatuses?: readonly VoiceProviderDecisionStatus[];
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+};
+export type VoiceProviderDecisionTraceRoutesOptions = VoiceProviderDecisionTraceReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProviderDecisionTraceReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const createVoiceProviderDecisionTraceEvent: (input: VoiceProviderDecisionTraceInput) => VoiceTraceEvent;
+export declare const listVoiceProviderDecisionTraces: (events: StoredVoiceTraceEvent[] | VoiceProviderDecisionTrace[]) => VoiceProviderDecisionTrace[];
+export declare const buildVoiceProviderDecisionTraceReport: (options: VoiceProviderDecisionTraceReportOptions) => Promise<VoiceProviderDecisionTraceReport>;
+export declare const renderVoiceProviderDecisionTraceMarkdown: (report: VoiceProviderDecisionTraceReport) => string;
+export declare const renderVoiceProviderDecisionTraceHTML: (report: VoiceProviderDecisionTraceReport, title?: string) => string;
+export declare const createVoiceProviderDecisionTraceRoutes: (options: VoiceProviderDecisionTraceRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/providerOrchestration.d.ts

@@ -0,0 +1,109 @@
+import { Elysia } from 'elysia';
+import type { VoiceProviderOrchestrationProfile, VoiceProviderRouterProviderProfile } from './modelAdapters';
+import type { VoiceSessionRecord } from './types';
+export type VoiceProviderOrchestrationStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProviderOrchestrationRequirement = {
+    minProviders?: number;
+    requireBudgetPolicy?: boolean;
+    requireCircuitBreaker?: boolean;
+    requireFallback?: boolean;
+    requireTimeoutBudget?: boolean;
+};
+export type VoiceProviderOrchestrationIssue = {
+    code: string;
+    message: string;
+    status: Exclude<VoiceProviderOrchestrationStatus, 'pass'>;
+    surface?: string;
+};
+export type VoiceProviderOrchestrationSurfaceReport = {
+    allowProviders: string[];
+    budgetPolicy: {
+        maxCost?: number;
+        maxLatencyMs?: number;
+        minQuality?: number;
+    };
+    circuitBreaker: boolean;
+    fallbackMode?: string;
+    fallbackProviders: string[];
+    issues: VoiceProviderOrchestrationIssue[];
+    providerProfiles: Record<string, VoiceProviderRouterProviderProfile>;
+    providers: string[];
+    status: VoiceProviderOrchestrationStatus;
+    strategy?: string;
+    surface: string;
+    timeoutBudget: boolean;
+    timeoutMs?: number;
+};
+export type VoiceProviderOrchestrationReport = {
+    checkedAt: number;
+    issues: VoiceProviderOrchestrationIssue[];
+    profileId: string;
+    status: VoiceProviderOrchestrationStatus;
+    summary: {
+        failed: number;
+        passed: number;
+        providers: number;
+        surfaces: number;
+        warned: number;
+    };
+    surfaces: VoiceProviderOrchestrationSurfaceReport[];
+};
+export type VoiceProviderOrchestrationReportOptions<TProvider extends string = string, TSurface extends string = string> = {
+    defaultRequirement?: VoiceProviderOrchestrationRequirement;
+    profile: VoiceProviderOrchestrationProfile<unknown, VoiceSessionRecord, TProvider, TSurface>;
+    requirements?: Partial<Record<TSurface, VoiceProviderOrchestrationRequirement>>;
+};
+export type VoiceProviderOrchestrationRoutesOptions<TProvider extends string = string, TSurface extends string = string> = VoiceProviderOrchestrationReportOptions<TProvider, TSurface> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProviderOrchestrationReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceProviderOrchestrationReport: <TProvider extends string = string, TSurface extends string = string>(options: VoiceProviderOrchestrationReportOptions<TProvider, TSurface>) => VoiceProviderOrchestrationReport;
+export declare const renderVoiceProviderOrchestrationMarkdown: (report: VoiceProviderOrchestrationReport) => string;
+export declare const renderVoiceProviderOrchestrationHTML: (report: VoiceProviderOrchestrationReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderOrchestrationRoutes: <TProvider extends string = string, TSurface extends string = string>(options: VoiceProviderOrchestrationRoutesOptions<TProvider, TSurface>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceProviderOrchestrationReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/providerRoutingContract.d.ts

@@ -0,0 +1,71 @@
+import { type VoiceRoutingEvent, type VoiceRoutingEventKind } from './resilienceRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderRoutingStatus = 'error' | 'fallback' | 'success';
+export type VoiceProviderRoutingExpectation = {
+    fallbackProvider?: string;
+    kind?: VoiceRoutingEventKind;
+    operation?: string;
+    provider?: string;
+    selectedProvider?: string;
+    status?: VoiceProviderRoutingStatus;
+};
+export type VoiceProviderRoutingContractDefinition = {
+    description?: string;
+    expect: VoiceProviderRoutingExpectation[];
+    id: string;
+    label?: string;
+    scenarioId?: string;
+    sessionId?: string;
+};
+export type VoiceProviderRoutingContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceProviderRoutingContractReport = {
+    contractId: string;
+    events: VoiceRoutingEvent[];
+    issues: VoiceProviderRoutingContractIssue[];
+    pass: boolean;
+    scenarioId?: string;
+    sessionId?: string;
+};
+export type VoiceProviderRoutingContractRunOptions = {
+    contract: VoiceProviderRoutingContractDefinition;
+    events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
+    store?: VoiceTraceEventStore;
+};
+export type VoiceProviderRoutingContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minEvents?: number;
+    requiredContractIds?: string[];
+    requiredFallbackProviders?: string[];
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredOperations?: string[];
+    requiredProviders?: string[];
+    requiredScenarioIds?: string[];
+    requiredSelectedProviders?: string[];
+    requiredStatuses?: VoiceProviderRoutingStatus[];
+};
+export type VoiceProviderRoutingContractAssertionReport = {
+    contractIds: string[];
+    events: number;
+    failed: number;
+    fallbackProviders: string[];
+    issues: string[];
+    issueCount: number;
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    operations: string[];
+    passed: number;
+    providers: string[];
+    scenarioIds: string[];
+    selectedProviders: string[];
+    statuses: VoiceProviderRoutingStatus[];
+    total: number;
+};
+export declare const runVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
+export declare const assertVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
+export declare const evaluateVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;
+export declare const assertVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;

package/dist/providerSlo.d.ts

@@ -0,0 +1,142 @@
+import { Elysia } from 'elysia';
+import { type VoiceRoutingEvent, type VoiceRoutingEventKind } from './resilienceRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderSloStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProviderSloThresholds = {
+    maxAverageElapsedMs?: number;
+    maxErrorRate?: number;
+    maxFallbackRate?: number;
+    maxP95ElapsedMs?: number;
+    maxTimeoutRate?: number;
+    minSamples?: number;
+};
+export type VoiceProviderSloThresholdConfig = Partial<Record<VoiceRoutingEventKind, VoiceProviderSloThresholds>>;
+export type VoiceProviderSloMetric = {
+    actual: number;
+    label: string;
+    pass: boolean;
+    threshold: number;
+    unit: 'count' | 'ms' | 'rate';
+};
+export type VoiceProviderSloIssue = {
+    code: string;
+    detail?: string;
+    kind?: VoiceRoutingEventKind;
+    label: string;
+    sessionId?: string;
+    status: Exclude<VoiceProviderSloStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceProviderSloKindReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: VoiceProviderSloIssue[];
+    kind: VoiceRoutingEventKind;
+    metrics: Record<string, VoiceProviderSloMetric>;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    thresholds: Required<VoiceProviderSloThresholds>;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export type VoiceProviderSloSessionReport = {
+    errorCount: number;
+    fallbackCount: number;
+    kinds: VoiceRoutingEventKind[];
+    lastEventAt: number;
+    maxElapsedMs?: number;
+    sessionId: string;
+    status: VoiceProviderSloStatus;
+    timeoutCount: number;
+};
+export type VoiceProviderSloReport = {
+    checkedAt: number;
+    events: number;
+    eventsWithLatency: number;
+    issues: VoiceProviderSloIssue[];
+    kinds: Record<VoiceRoutingEventKind, VoiceProviderSloKindReport>;
+    sessions: VoiceProviderSloSessionReport[];
+    status: VoiceProviderSloStatus;
+    thresholds: Record<VoiceRoutingEventKind, Required<VoiceProviderSloThresholds>>;
+};
+export type VoiceProviderSloReportOptions = {
+    events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    requiredKinds?: readonly VoiceRoutingEventKind[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceProviderSloThresholdConfig;
+};
+export type VoiceProviderSloRoutesOptions = VoiceProviderSloReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProviderSloReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderSloAssertionInput = {
+    fallbackKinds?: VoiceRoutingEventKind[];
+    maxAverageElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxIssues?: number;
+    maxP95ElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxStatus?: VoiceProviderSloStatus;
+    maxTimeouts?: number;
+    maxUnresolvedErrors?: number;
+    minEvents?: number;
+    minFallbacks?: number;
+    minLatencySamples?: number;
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredProviders?: string[];
+};
+export type VoiceProviderSloAssertionReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: string[];
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export declare const buildVoiceProviderSloReport: (options?: VoiceProviderSloReportOptions) => Promise<VoiceProviderSloReport>;
+export declare const evaluateVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const assertVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const renderVoiceProviderSloMarkdown: (report: VoiceProviderSloReport) => string;
+export declare const renderVoiceProviderSloHTML: (report: VoiceProviderSloReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderSloRoutes: (options: VoiceProviderSloRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/providerStackRecommendations.d.ts

@@ -0,0 +1,187 @@
+import { Elysia } from 'elysia';
+import type { VoiceReadinessProfileName } from './readinessProfiles';
+export type VoiceProviderStackKind = 'llm' | 'stt' | 'tts';
+export type VoiceProviderStackInput<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+};
+export type VoiceProviderStackChoice<TProvider extends string = string> = {
+    alternatives: TProvider[];
+    provider?: TProvider;
+    reasons: string[];
+};
+export type VoiceProviderStackRecommendation<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    recommended: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    stacks: Partial<Record<VoiceProviderStackKind, VoiceProviderStackChoice<TProvider>>>;
+};
+export type VoiceProviderStackCapabilities<TProvider extends string = string> = Partial<Record<VoiceProviderStackKind, Partial<Record<TProvider, readonly string[]>>>>;
+export type VoiceProviderStackCapabilityGap<TProvider extends string = string> = {
+    kind: VoiceProviderStackKind;
+    missing: string[];
+    present: string[];
+    provider?: TProvider;
+    required: string[];
+    status: 'fail' | 'pass' | 'warn';
+};
+export type VoiceProviderStackCapabilityGapReport<TProvider extends string = string> = {
+    gaps: VoiceProviderStackCapabilityGap<TProvider>[];
+    missing: number;
+    profile: VoiceReadinessProfileName;
+    status: 'fail' | 'pass' | 'warn';
+};
+export type VoiceProviderStackAssertionInput<TProvider extends string = string> = {
+    maxMissing?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    requireProviders?: boolean;
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    requiredCapabilities?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderStackAssertionReport<TProvider extends string = string> = {
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    missing: number;
+    ok: boolean;
+    providers: TProvider[];
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderStackCapabilityGapInput<TProvider extends string = string> = VoiceProviderStackInput<TProvider> & {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    recommendation?: VoiceProviderStackRecommendation<TProvider>;
+    required?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderContractCheckStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProviderContractRemediation = {
+    code: string;
+    detail: string;
+    href?: string;
+    label: string;
+};
+export type VoiceProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    remediation?: VoiceProviderContractRemediation;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly string[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    kind: VoiceProviderStackKind;
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    requiredCapabilities?: readonly string[];
+    requiredEnv?: readonly string[];
+    remediationHref?: string;
+    selected?: boolean;
+    streaming?: boolean;
+};
+export type VoiceProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceProviderContractDefinition<TProvider>[];
+};
+export type VoiceProviderContractMatrixPresetOptions<TProvider extends string = string> = {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    configured?: Partial<Record<TProvider, boolean>>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    remediationHref?: string;
+    selected?: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    streaming?: Partial<Record<TProvider, boolean>>;
+};
+export type VoiceProviderContractMatrixHandlerOptions<TProvider extends string = string> = VoiceProviderContractMatrixInput<TProvider> | (() => Promise<VoiceProviderContractMatrixInput<TProvider>> | VoiceProviderContractMatrixInput<TProvider>);
+export type VoiceProviderContractMatrixHTMLHandlerOptions<TProvider extends string = string> = {
+    matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>;
+    render?: (report: VoiceProviderContractMatrixReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderContractMatrixRoutesOptions<TProvider extends string = string> = VoiceProviderContractMatrixHTMLHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceProviderContractMatrixRow<TProvider extends string = string> = {
+    checks: VoiceProviderContractCheck[];
+    configured: boolean;
+    kind: VoiceProviderStackKind;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceProviderContractMatrixRow<TProvider>[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceProviderContractMatrixAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireAllSelected?: boolean;
+    requiredCheckKeys?: string[];
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    selectedKinds?: VoiceProviderStackKind[];
+};
+export type VoiceProviderContractMatrixAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedKinds: VoiceProviderStackKind[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export declare const recommendVoiceProviderStack: <TProvider extends string = string>(input: VoiceProviderStackInput<TProvider>) => VoiceProviderStackRecommendation<TProvider>;
+export declare const buildVoiceProviderContractMatrix: <TProvider extends string = string>(input: VoiceProviderContractMatrixInput<TProvider>) => VoiceProviderContractMatrixReport<TProvider>;
+export declare const evaluateVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const assertVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const createVoiceProviderContractMatrixPreset: <TProvider extends string = string>(profile: VoiceReadinessProfileName, options: VoiceProviderContractMatrixPresetOptions<TProvider>) => VoiceProviderContractMatrixInput<TProvider>;
+export declare const renderVoiceProviderContractMatrixHTML: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderContractMatrixJSONHandler: <TProvider extends string = string>(matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>) => () => Promise<VoiceProviderContractMatrixReport<TProvider>>;
+export declare const createVoiceProviderContractMatrixHTMLHandler: <TProvider extends string = string>(options: VoiceProviderContractMatrixHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderContractMatrixRoutes: <TProvider extends string = string>(options: VoiceProviderContractMatrixRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const evaluateVoiceProviderStackGaps: <TProvider extends string = string>(input: VoiceProviderStackCapabilityGapInput<TProvider>) => VoiceProviderStackCapabilityGapReport<TProvider>;
+export declare const evaluateVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const assertVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;