@absolutejs/voice 0.0.22-beta.52 → 0.0.22-beta.520

package/dist/pathway.d.ts

@@ -0,0 +1,94 @@
+export type VoicePathwaySlotType = "string" | "number" | "boolean" | "date" | "time" | "phone" | "email" | "currency" | "choice";
+export type VoicePathwaySlot = {
+    id: string;
+    type: VoicePathwaySlotType;
+    prompt: string;
+    required?: boolean;
+    choices?: string[];
+    description?: string;
+    validation?: {
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        min?: number;
+        max?: number;
+    };
+};
+export type VoicePathwayCondition = {
+    kind: "slot-equals";
+    slotId: string;
+    value: string | number | boolean;
+} | {
+    kind: "slot-filled";
+    slotId: string;
+} | {
+    kind: "slot-matches";
+    slotId: string;
+    pattern: string;
+} | {
+    kind: "always";
+} | {
+    kind: "fallback";
+};
+export type VoicePathwayAction = {
+    kind: "say";
+    text: string;
+} | {
+    kind: "collect-slot";
+    slotId: string;
+} | {
+    kind: "call-tool";
+    toolId: string;
+    argsFromSlots?: string[];
+} | {
+    kind: "set-slot";
+    slotId: string;
+    valueExpression: string;
+} | {
+    kind: "transfer";
+    destination: string;
+} | {
+    kind: "end-call";
+    reason?: string;
+};
+export type VoicePathwayTransition = {
+    to: string;
+    condition: VoicePathwayCondition;
+    description?: string;
+};
+export type VoicePathwayState = {
+    id: string;
+    label: string;
+    kind?: "entry" | "collect" | "branch" | "action" | "terminal";
+    description?: string;
+    systemNote?: string;
+    actions?: VoicePathwayAction[];
+    transitions: VoicePathwayTransition[];
+};
+export type VoicePathway = {
+    id: string;
+    label: string;
+    entryStateId: string;
+    states: VoicePathwayState[];
+    slots: VoicePathwaySlot[];
+    tools?: {
+        id: string;
+        description: string;
+    }[];
+    metadata?: Record<string, string>;
+};
+export type VoicePathwayValidationIssue = {
+    severity: "error" | "warning";
+    code: "duplicate-state" | "duplicate-slot" | "unknown-entry" | "unreachable-state" | "missing-transition-target" | "missing-slot-ref" | "no-terminal-reachable" | "fallback-not-last" | "duplicate-transition";
+    message: string;
+    stateId?: string;
+    slotId?: string;
+};
+export type VoicePathwayValidationReport = {
+    valid: boolean;
+    issues: VoicePathwayValidationIssue[];
+    reachableStates: string[];
+};
+export declare const validateVoicePathway: (pathway: VoicePathway) => VoicePathwayValidationReport;
+export declare const findVoicePathwayState: (pathway: VoicePathway, id: string) => VoicePathwayState | null;
+export declare const findVoicePathwaySlot: (pathway: VoicePathway, id: string) => VoicePathwaySlot | null;

package/dist/pathwayCompiler.d.ts

@@ -0,0 +1,31 @@
+import { type VoicePathway } from "./pathway";
+export type VoicePathwayCompilerToolDefinition = {
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required: string[];
+    };
+};
+export type VoicePathwayCompiledAssistant = {
+    systemPrompt: string;
+    tools: VoicePathwayCompilerToolDefinition[];
+    initialPrompt?: string;
+    metadata: {
+        pathwayId: string;
+        pathwayLabel: string;
+        entryStateId: string;
+    };
+};
+export type CompileVoicePathwayOptions = {
+    pathway: VoicePathway;
+    introduction?: string;
+    fallbackBehavior?: "stay" | "end-call" | "transfer";
+    toolNamePrefix?: string;
+};
+export declare const compileVoicePathwayToAssistant: (options: CompileVoicePathwayOptions) => VoicePathwayCompiledAssistant;

package/dist/pathwayRuntime.d.ts

@@ -0,0 +1,57 @@
+import { type VoicePathway, type VoicePathwayAction } from "./pathway";
+export type VoicePathwaySlotValue = string | number | boolean | null;
+export type VoicePathwayRuntimeStatus = "ready" | "awaiting-slot" | "branching" | "ended" | "errored";
+export type VoicePathwayRuntimeState = {
+    currentStateId: string;
+    status: VoicePathwayRuntimeStatus;
+    slots: Record<string, VoicePathwaySlotValue>;
+    awaitingSlotId: string | null;
+    history: {
+        stateId: string;
+        at: number;
+    }[];
+    pendingActions: VoicePathwayAction[];
+    lastError?: string;
+    endedReason?: string;
+};
+export type VoicePathwayToolCall = {
+    toolId: string;
+    args: Record<string, VoicePathwaySlotValue>;
+};
+export type VoicePathwayRuntimeEvent = {
+    type: "say";
+    text: string;
+} | {
+    type: "ask-slot";
+    slotId: string;
+    prompt: string;
+} | {
+    type: "tool-call";
+    call: VoicePathwayToolCall;
+} | {
+    type: "transfer";
+    destination: string;
+} | {
+    type: "end-call";
+    reason?: string;
+} | {
+    type: "state-entered";
+    stateId: string;
+} | {
+    type: "errored";
+    message: string;
+};
+export type CreateVoicePathwayRuntimeOptions = {
+    pathway: VoicePathway;
+    initialSlots?: Record<string, VoicePathwaySlotValue>;
+    now?: () => number;
+    skipValidation?: boolean;
+};
+export declare const createVoicePathwayRuntime: (options: CreateVoicePathwayRuntimeOptions) => {
+    fillSlot: (slotId: string, value: VoicePathwaySlotValue) => void;
+    getState: () => VoicePathwayRuntimeState;
+    start: () => void;
+    subscribe(listener: (event: VoicePathwayRuntimeEvent) => void): () => void;
+    tryTransition: () => void;
+};
+export type VoicePathwayRuntime = ReturnType<typeof createVoicePathwayRuntime>;

package/dist/pathwaySlotCollector.d.ts

@@ -0,0 +1,29 @@
+import type { VoicePathwaySlot, VoicePathwaySlotType } from "./pathway";
+import type { VoicePathwaySlotValue } from "./pathwayRuntime";
+export type VoicePathwaySlotParseResult = {
+    ok: true;
+    value: VoicePathwaySlotValue;
+    normalized: string;
+} | {
+    ok: false;
+    reason: "empty" | "type-mismatch" | "out-of-range" | "no-match";
+    hint?: string;
+};
+export type VoicePathwaySlotParser = (raw: string, slot: VoicePathwaySlot) => VoicePathwaySlotParseResult;
+export declare const DEFAULT_VOICE_PATHWAY_SLOT_PARSERS: Record<VoicePathwaySlotType, VoicePathwaySlotParser>;
+export type CreateVoicePathwaySlotCollectorOptions = {
+    parsers?: Partial<Record<VoicePathwaySlotType, VoicePathwaySlotParser>>;
+    maxAttemptsPerSlot?: number;
+};
+export type VoicePathwaySlotCollectorAttempt = {
+    slotId: string;
+    raw: string;
+    result: VoicePathwaySlotParseResult;
+    attempt: number;
+};
+export declare const createVoicePathwaySlotCollector: (options?: CreateVoicePathwaySlotCollectorOptions) => {
+    attemptsExceeded: (slotId: string) => boolean;
+    interpret: (slot: VoicePathwaySlot, raw: string) => VoicePathwaySlotCollectorAttempt;
+    reset: (slotId?: string) => void;
+};
+export type VoicePathwaySlotCollector = ReturnType<typeof createVoicePathwaySlotCollector>;

package/dist/pathwayVisualizer.d.ts

@@ -0,0 +1,8 @@
+import type { VoicePathway } from "./pathway";
+export declare const renderVoicePathwayMermaid: (pathway: VoicePathway) => string;
+export declare const renderVoicePathwayText: (pathway: VoicePathway) => string;
+export type VoicePathwayVisualization = {
+    mermaid: string;
+    text: string;
+};
+export declare const visualizeVoicePathway: (pathway: VoicePathway) => VoicePathwayVisualization;

package/dist/phoneAgent.d.ts

@@ -0,0 +1,139 @@
+import { Elysia } from "elysia";
+import { type PlivoVoiceRoutesOptions } from "./telephony/plivo";
+import { type TelnyxVoiceRoutesOptions } from "./telephony/telnyx";
+import { type TwilioVoiceRoutesOptions } from "./telephony/twilio";
+import { type VoiceTelephonyCarrierMatrix, type VoiceTelephonyCarrierMatrixRoutesOptions } from "./telephony/matrix";
+import { type VoicePhoneAgentProductionSmokeRoutesOptions } from "./phoneAgentProductionSmoke";
+import { type VoiceCampaignDialerProofAssertionReport, type VoiceCampaignDialerProofProvider, type VoiceCampaignDialerProofReport } from "./campaignDialers";
+import type { VoiceTelephonyProvider } from "./telephony/contract";
+import type { VoicePhoneAgentProductionSmokeReport } from "./phoneAgentProductionSmoke";
+import type { VoiceSessionRecord } from "./types";
+export type VoicePhoneAgentLifecycleStage = "ringing" | "answered" | "media-started" | "transcript" | "assistant-response" | "transfer" | "voicemail" | "no-answer" | "completed" | "failed";
+type VoicePhoneAgentCarrierBase = {
+    name?: string;
+    smokePath?: false | string;
+    setupPath?: false | string;
+};
+export type VoicePhoneAgentTwilioCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options: TwilioVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "twilio";
+};
+export type VoicePhoneAgentTelnyxCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "telnyx";
+};
+export type VoicePhoneAgentPlivoCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "plivo";
+};
+export type VoicePhoneAgentCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentTwilioCarrier<TContext, TSession, TResult> | VoicePhoneAgentTelnyxCarrier<TContext, TSession, TResult> | VoicePhoneAgentPlivoCarrier<TContext, TSession, TResult>;
+export type VoicePhoneAgentRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    carriers: readonly VoicePhoneAgentCarrier<TContext, TSession, TResult>[];
+    matrix?: false | Omit<VoiceTelephonyCarrierMatrixRoutesOptions, "load">;
+    name?: string;
+    productionSmoke?: false | VoicePhoneAgentProductionSmokeRoutesOptions;
+    setup?: false | {
+        path?: string;
+        title?: string;
+    };
+};
+export type VoicePhoneAgentCarrierSummary = {
+    name?: string;
+    provider: "plivo" | "telnyx" | "twilio";
+    setupPath?: false | string;
+    smokePath?: false | string;
+};
+export type VoicePhoneAgentSetupInstruction = {
+    answerLabel: string;
+    answerUrl?: string;
+    carrierName: string;
+    issues: string[];
+    provider: "plivo" | "telnyx" | "twilio";
+    setupPath?: false | string;
+    smokePath?: false | string;
+    status: "fail" | "pass" | "unknown" | "warn";
+    steps: string[];
+    streamUrl?: string;
+    webhookUrl?: string;
+};
+export type VoicePhoneAgentRoutes = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    matrixPath?: string;
+    productionSmokePath?: string;
+    routes: Elysia;
+    setupPath?: string;
+};
+export type VoicePhoneAgentSetupReport = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    generatedAt: number;
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    matrix?: VoiceTelephonyCarrierMatrix;
+    matrixPath?: string;
+    productionSmokePath?: string;
+    ready: boolean;
+    setupInstructions: VoicePhoneAgentSetupInstruction[];
+    setupPath?: string;
+    title: string;
+};
+export type VoicePhoneAssistantEvidenceInput = {
+    dialerProof?: VoiceCampaignDialerProofReport;
+    maxCarrierFailures?: number;
+    maxCarrierWarnings?: number;
+    maxFailedDialerProviders?: number;
+    minCarriers?: number;
+    minDialerCarrierRequests?: number;
+    minReadyCarriers?: number;
+    minSmokePassing?: number;
+    minSuccessfulDialerOutcomes?: number;
+    requiredDialerProviders?: VoiceCampaignDialerProofProvider[];
+    requiredLifecycleStages?: VoicePhoneAgentLifecycleStage[];
+    requiredProviders?: VoiceTelephonyProvider[];
+    requireCarrierMatrix?: boolean;
+    requireDialerProof?: boolean;
+    requireMatrixPass?: boolean;
+    requireProductionSmokePath?: boolean;
+    requireReady?: boolean;
+    requireSetupPath?: boolean;
+};
+export type VoicePhoneAssistantEvidenceReport = {
+    carrierFailures: number;
+    carrierWarnings: number;
+    carriers: number;
+    dialer?: VoiceCampaignDialerProofAssertionReport;
+    issues: string[];
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    matrixPass?: boolean;
+    ok: boolean;
+    productionSmokePath?: string;
+    providers: VoiceTelephonyProvider[];
+    ready: boolean;
+    readyCarriers: number;
+    setupPath?: string;
+    smokePassing: number;
+};
+export type VoicePhoneCallControlEvidenceInput = {
+    maxFailedSmokeReports?: number;
+    minPassingSmokeReports?: number;
+    productionSmokes?: VoicePhoneAgentProductionSmokeReport[];
+    requiredLifecycleStages?: VoicePhoneAgentLifecycleStage[];
+    requiredOutcomes?: string[];
+    requiredProviders?: VoiceTelephonyProvider[];
+    requireSetupLifecycleStages?: boolean;
+    setup?: VoicePhoneAgentSetupReport;
+};
+export type VoicePhoneCallControlEvidenceReport = {
+    failedSmokeReports: number;
+    issues: string[];
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    ok: boolean;
+    outcomes: string[];
+    passingSmokeReports: number;
+    providers: VoiceTelephonyProvider[];
+    smokeReports: number;
+};
+export declare const evaluateVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
+export declare const assertVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
+export declare const evaluateVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
+export declare const assertVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
+export declare const createVoicePhoneAgent: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoicePhoneAgentRoutesOptions<TContext, TSession, TResult>) => VoicePhoneAgentRoutes;
+export {};

package/dist/phoneAgentProductionSmoke.d.ts

@@ -0,0 +1,115 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { VoiceTelephonyContractReport, VoiceTelephonyProvider } from "./telephony/contract";
+export type VoicePhoneAgentProductionSmokeRequirement = "assistant-response" | "carrier-contract" | "fresh-trace" | "lifecycle-outcome" | "media-started" | "no-session-error" | "transcript";
+export type VoicePhoneAgentProductionSmokeIssue = {
+    message: string;
+    requirement: VoicePhoneAgentProductionSmokeRequirement;
+    severity: "error" | "warning";
+};
+export type VoicePhoneAgentProductionSmokeReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId: string;
+    generatedAt: number;
+    issues: VoicePhoneAgentProductionSmokeIssue[];
+    maxAgeMs?: number;
+    observed: {
+        assistantResponses: number;
+        carrierContract?: boolean;
+        lifecycleOutcomes: string[];
+        latestEventAt?: number;
+        mediaStarts: number;
+        sessionErrors: number;
+        transcripts: number;
+    };
+    pass: boolean;
+    provider?: TProvider;
+    required: VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId?: string;
+    events?: readonly StoredVoiceTraceEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    provider?: TProvider;
+    required?: readonly VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = Omit<VoicePhoneAgentProductionSmokeOptions<TProvider>, "events" | "scenarioId" | "sessionId" | "traceId"> & {
+    getContract?: (input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyContractReport<TProvider> | undefined> | VoiceTelephonyContractReport<TProvider> | undefined;
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (report: VoicePhoneAgentProductionSmokeReport<TProvider>) => Promise<string> | string;
+    title?: string;
+};
+export type VoicePhoneAgentProductionSmokeRoutesOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoicePhoneAgentProductionSmokeContract: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeOptions<TProvider>) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const renderVoicePhoneAgentProductionSmokeHTML: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(report: VoicePhoneAgentProductionSmokeReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoicePhoneAgentProductionSmokeJSONHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHandlerOptions<TProvider>) => ({ query, request, }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const createVoicePhoneAgentProductionSmokeHTMLHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider>) => ({ query, request, }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<Response>;
+export declare const createVoicePhoneAgentProductionSmokeRoutes: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeRoutesOptions<TProvider>) => 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: VoicePhoneAgentProductionSmokeReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/phoneProvisioning.d.ts

@@ -0,0 +1,29 @@
+export type VoicePhoneNumber = {
+    phoneNumber: string;
+    provider: "telnyx" | "twilio" | (string & {});
+    providerNumberId: string;
+    raw: unknown;
+};
+export type TwilioProvisionInput = {
+    accountSid: string;
+    areaCode?: string;
+    authToken: string;
+    contains?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    friendlyName?: string;
+    smsUrl?: string;
+    statusCallbackUrl?: string;
+    voiceUrl: string;
+};
+export declare const provisionTwilioPhoneNumber: (input: TwilioProvisionInput) => Promise<VoicePhoneNumber>;
+export type TelnyxProvisionInput = {
+    apiKey: string;
+    areaCode?: string;
+    connectionId?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    messagingProfileId?: string;
+    voiceWebhookUrl: string;
+};
+export declare const provisionTelnyxPhoneNumber: (input: TelnyxProvisionInput) => Promise<VoicePhoneNumber>;

package/dist/platformCoverage.d.ts

@@ -0,0 +1,91 @@
+import { Elysia } from "elysia";
+export type VoicePlatformCoverageStatus = "fail" | "missing" | "pass" | "stale";
+export type VoicePlatformCoverageEvidence = {
+    method?: string;
+    name: string;
+    ok?: boolean;
+    path?: string;
+    status?: number;
+    url?: string;
+};
+export type VoicePlatformCoverageSurface = {
+    evidence: VoicePlatformCoverageEvidence[];
+    failed?: number;
+    gap?: string;
+    missing?: number;
+    missingEvidence?: string[];
+    replacement: string;
+    status: "fail" | "pass" | string;
+    surface: string;
+};
+export type VoicePlatformCoverageSummary = {
+    generatedAt?: string;
+    ok: boolean;
+    outputDir?: string;
+    runId?: string;
+    source?: string;
+    status: VoicePlatformCoverageStatus;
+    total: number;
+    coverage: VoicePlatformCoverageSurface[];
+};
+export type VoicePlatformCoverageSummaryInput = {
+    coverage?: VoicePlatformCoverageSurface[];
+    generatedAt?: string;
+    ok?: boolean;
+    outputDir?: string;
+    runId?: string;
+    source?: string;
+};
+export type VoicePlatformCoverageRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source: (() => Promise<VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput> | VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput) | VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput;
+};
+export type VoicePlatformCoverageAssertionInput = {
+    maxFailedSurfaces?: number;
+    minSurfaces?: number;
+    requiredEvidence?: string[];
+    requiredSurfaces?: string[];
+    requirePass?: boolean;
+};
+export type VoicePlatformCoverageAssertionReport = {
+    failed: number;
+    issues: string[];
+    missing: number;
+    ok: boolean;
+    status: VoicePlatformCoverageStatus;
+    surfaces: string[];
+    total: number;
+};
+export declare const buildVoicePlatformCoverageSummary: (input: VoicePlatformCoverageSummaryInput) => VoicePlatformCoverageSummary;
+export declare const evaluateVoicePlatformCoverage: (summary: VoicePlatformCoverageSummary, input?: VoicePlatformCoverageAssertionInput) => VoicePlatformCoverageAssertionReport;
+export declare const assertVoicePlatformCoverage: (summary: VoicePlatformCoverageSummary, input?: VoicePlatformCoverageAssertionInput) => VoicePlatformCoverageAssertionReport;
+export declare const createVoicePlatformCoverageRoutes: (options: VoicePlatformCoverageRoutesOptions) => 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/plugin.d.ts

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
-import type { VoicePluginConfig, VoiceSessionRecord } from './types';
+import { Elysia } from "elysia";
+import type { VoicePluginConfig, VoiceSessionRecord } from "./types";
 export declare const voice: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(config: VoicePluginConfig<TContext, TSession, TResult>) => Elysia<"", {
     decorator: {};
     store: {};