@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/core/profileSwitchRecommendation.d.ts

@@ -0,0 +1,350 @@
+import { Elysia } from "elysia";
+import type { VoiceRealCallProfileDefault, VoiceRealCallProfileDefaultsReport, VoiceRealCallProfileHistoryReport } from "./proofTrends";
+import { type StoredVoiceAuditEvent, type VoiceAuditActor, type VoiceAuditEventStore } from "./audit";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceProfileSwitchObservedSignals = {
+    currentProfileId?: string;
+    fallbackUsed?: boolean;
+    liveP95Ms?: number;
+    providerP95Ms?: number;
+    turnP95Ms?: number;
+    turnWarnings?: number;
+};
+export type VoiceProfileSwitchRecommendation = {
+    currentProfile?: {
+        label?: string;
+        profileId: string;
+        status: string;
+    };
+    generatedAt: string;
+    issues: string[];
+    nextMove: string;
+    ok: boolean;
+    observed: VoiceProfileSwitchObservedSignals;
+    reasons: string[];
+    recommendedProfile?: {
+        evidence: VoiceRealCallProfileDefault["evidence"];
+        label?: string;
+        latencyBudgets: VoiceRealCallProfileDefault["latencyBudgets"];
+        profileId: string;
+        providerRoutes: Record<string, string>;
+        status: string;
+    };
+    status: "stay" | "switch" | "warn";
+};
+export type VoiceProfileSwitchRecommendationOptions = {
+    defaultProfileId?: string;
+    defaults: VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport;
+    minImprovementMs?: number;
+    observed?: VoiceProfileSwitchObservedSignals;
+};
+export type VoiceProfileSwitchGuardMode = "auto" | "off" | "recommend";
+export type VoiceProfileSwitchGuardAction = "blocked" | "disabled" | "recommend" | "stay" | "switch";
+export type VoiceProfileSwitchGuardDecision = {
+    action: VoiceProfileSwitchGuardAction;
+    auditEvent?: StoredVoiceAuditEvent;
+    autoApplied: boolean;
+    autoSwitchCount: number;
+    blockedByPolicy?: "allowed-profiles" | "blocked-profiles" | "max-switches";
+    confidence: number;
+    minConfidence: number;
+    mode: VoiceProfileSwitchGuardMode;
+    maxAutoSwitchesPerSession: number;
+    previousProfileId?: string;
+    reason: string;
+    recommendation: VoiceProfileSwitchRecommendation;
+    recommendedProfileId?: string;
+    selectedProfileId?: string;
+};
+export type VoiceProfileSwitchGuardOptions = VoiceProfileSwitchRecommendationOptions & {
+    actor?: VoiceAuditActor;
+    allowedProfileIds?: string[];
+    audit?: VoiceAuditEventStore;
+    autoSwitchCount?: number;
+    blockedProfileIds?: string[];
+    maxAutoSwitchesPerSession?: number;
+    metadata?: Record<string, unknown>;
+    minConfidence?: number;
+    mode?: VoiceProfileSwitchGuardMode;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoiceProfileSwitchPolicyProofCase = {
+    description?: string;
+    expectedAction?: VoiceProfileSwitchGuardAction;
+    expectedBlockedByPolicy?: VoiceProfileSwitchGuardDecision["blockedByPolicy"];
+    id: string;
+    label?: string;
+    options?: Partial<Omit<VoiceProfileSwitchGuardOptions, "defaults" | "observed">> & {
+        observed?: VoiceProfileSwitchObservedSignals;
+    };
+};
+export type VoiceProfileSwitchPolicyProofCaseResult = VoiceProfileSwitchPolicyProofCase & {
+    decision: VoiceProfileSwitchGuardDecision;
+    ok: boolean;
+};
+export type VoiceProfileSwitchPolicyProofReport = {
+    generatedAt: string;
+    ok: boolean;
+    observed: VoiceProfileSwitchObservedSignals;
+    results: VoiceProfileSwitchPolicyProofCaseResult[];
+    summary: {
+        failed: number;
+        passed: number;
+        total: number;
+    };
+};
+export type VoiceProfileSwitchPolicyProofOptions = {
+    actor?: VoiceAuditActor;
+    allowedProfileIds?: string[];
+    audit?: VoiceAuditEventStore;
+    cases?: VoiceProfileSwitchPolicyProofCase[];
+    defaults: VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport | (() => Promise<VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport> | VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport);
+    metadata?: Record<string, unknown>;
+    minConfidence?: number;
+    observed?: VoiceProfileSwitchObservedSignals;
+    title?: string;
+};
+export type VoiceProfileSwitchPolicyProofRoutesOptions = VoiceProfileSwitchPolicyProofOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchPolicyProofReport) => string | Promise<string>;
+};
+export type VoiceProfileSwitchLiveDecisionEvidence = {
+    action?: VoiceProfileSwitchGuardAction | string;
+    at: number;
+    auditEventId?: string;
+    autoApplied?: boolean;
+    autoSwitchCount?: number;
+    blockedByPolicy?: string;
+    confidence?: number;
+    maxAutoSwitchesPerSession?: number;
+    minConfidence?: number;
+    mode?: VoiceProfileSwitchGuardMode | string;
+    outcome?: string;
+    previousProfileId?: string;
+    reason?: string;
+    recommendedProfileId?: string;
+    scenarioId?: string;
+    selectedProfileId?: string;
+    sessionId: string;
+    source: "audit" | "trace";
+    status?: string;
+    traceEventId?: string;
+    traceId?: string;
+};
+export type VoiceProfileSwitchLiveDecisionSession = {
+    actionCounts: Record<string, number>;
+    actions: string[];
+    autoApplied: number;
+    blockedByPolicy: string[];
+    decisions: VoiceProfileSwitchLiveDecisionEvidence[];
+    firstSeenAt: number;
+    lastDecision?: VoiceProfileSwitchLiveDecisionEvidence;
+    lastSeenAt: number;
+    sessionId: string;
+};
+export type VoiceProfileSwitchLiveDecisionReport = {
+    generatedAt: string;
+    ok: boolean;
+    sessions: VoiceProfileSwitchLiveDecisionSession[];
+    summary: {
+        auditEvents: number;
+        autoApplied: number;
+        blocked: number;
+        decisions: number;
+        recommendations: number;
+        sessions: number;
+        switches: number;
+        traceEvents: number;
+    };
+};
+export type VoiceProfileSwitchLiveDecisionReportOptions = {
+    audit?: VoiceAuditEventStore;
+    limit?: number;
+    sessionId?: string;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceProfileSwitchLiveDecisionRoutesOptions = VoiceProfileSwitchLiveDecisionReportOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchLiveDecisionReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProfileSwitchReadinessStatus = "fail" | "pass" | "warn";
+export type VoiceProfileSwitchReadinessIssue = {
+    code: string;
+    message: string;
+    status: Exclude<VoiceProfileSwitchReadinessStatus, "pass">;
+};
+export type VoiceProfileSwitchReadinessReport = {
+    generatedAt: string;
+    issues: VoiceProfileSwitchReadinessIssue[];
+    live: VoiceProfileSwitchLiveDecisionReport;
+    policy?: VoiceProfileSwitchPolicyProofReport;
+    status: VoiceProfileSwitchReadinessStatus;
+    summary: {
+        auditEvents: number;
+        autoApplied: number;
+        blocked: number;
+        decisions: number;
+        policyCases?: number;
+        sessions: number;
+        switches: number;
+        traceEvents: number;
+    };
+};
+export type VoiceProfileSwitchReadinessOptions = VoiceProfileSwitchLiveDecisionReportOptions & {
+    autoMode?: boolean;
+    maxBlockedRatio?: number;
+    maxAutoAppliedRatio?: number;
+    policyProof?: false | VoiceProfileSwitchPolicyProofOptions;
+    requireAudit?: boolean;
+    requireAllowedProfilePolicy?: boolean;
+    requireLiveDecisions?: boolean;
+    requirePolicyProof?: boolean;
+    requireTrace?: boolean;
+};
+export type VoiceProfileSwitchReadinessRoutesOptions = VoiceProfileSwitchReadinessOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchReadinessReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const applyVoiceProfileSwitchGuard: (options: VoiceProfileSwitchGuardOptions) => Promise<VoiceProfileSwitchGuardDecision>;
+export declare const recommendVoiceProfileSwitch: (options: VoiceProfileSwitchRecommendationOptions) => VoiceProfileSwitchRecommendation;
+export declare const createVoiceProfileSwitchPolicyProofRoutes: (options: VoiceProfileSwitchPolicyProofRoutesOptions) => 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: VoiceProfileSwitchPolicyProofReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceProfileSwitchPolicyProofHTML: (report: VoiceProfileSwitchPolicyProofReport, options?: {
+    title?: string;
+}) => string;
+export declare const runVoiceProfileSwitchPolicyProof: (options: VoiceProfileSwitchPolicyProofOptions) => Promise<VoiceProfileSwitchPolicyProofReport>;
+export declare const buildVoiceProfileSwitchLiveDecisionReport: (options: VoiceProfileSwitchLiveDecisionReportOptions) => Promise<VoiceProfileSwitchLiveDecisionReport>;
+export declare const createVoiceProfileSwitchLiveDecisionRoutes: (options: VoiceProfileSwitchLiveDecisionRoutesOptions) => 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: VoiceProfileSwitchLiveDecisionReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceProfileSwitchLiveDecisionHTML: (report: VoiceProfileSwitchLiveDecisionReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceProfileSwitchReadinessReport: (options: VoiceProfileSwitchReadinessOptions) => Promise<VoiceProfileSwitchReadinessReport>;
+export declare const createVoiceProfileSwitchReadinessRoutes: (options: VoiceProfileSwitchReadinessRoutesOptions) => 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: VoiceProfileSwitchReadinessReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceProfileSwitchReadinessHTML: (report: VoiceProfileSwitchReadinessReport, options?: {
+    title?: string;
+}) => string;

package/dist/core/promptInjectionGuard.d.ts

@@ -0,0 +1,30 @@
+import type { Transcript } from "./types";
+export type VoicePromptInjectionRule = {
+    /** Reason emitted in the verdict when this rule matches. */
+    label: string;
+    /** Regex applied to the transcript text (case-insensitive by convention). */
+    pattern: RegExp;
+    /** Severity tag for downstream routing. */
+    severity?: "high" | "low" | "medium";
+};
+export type VoicePromptInjectionVerdict = {
+    matches: Array<{
+        label: string;
+        matchedText: string;
+        severity?: VoicePromptInjectionRule["severity"];
+    }>;
+    ok: boolean;
+};
+export declare const DEFAULT_VOICE_PROMPT_INJECTION_RULES: VoicePromptInjectionRule[];
+export type CreateVoicePromptInjectionGuardOptions = {
+    /** Custom rule set. Defaults to DEFAULT_VOICE_PROMPT_INJECTION_RULES. */
+    rules?: ReadonlyArray<VoicePromptInjectionRule>;
+    /** Replacement string for sanitized text. Default '[REDACTED:INJECTION]'. */
+    sanitizedReplacement?: string;
+};
+export type VoicePromptInjectionGuard = {
+    evaluate: (input: string | Transcript) => VoicePromptInjectionVerdict;
+    rules: ReadonlyArray<VoicePromptInjectionRule>;
+    sanitize: (input: string) => string;
+};
+export declare const createVoicePromptInjectionGuard: (options?: CreateVoicePromptInjectionGuardOptions) => VoicePromptInjectionGuard;

package/dist/core/proofAssertions.d.ts

@@ -0,0 +1,32 @@
+export type VoiceProofAssertionResult = {
+    kind: "json-assertion";
+    name: string;
+    ok: boolean;
+    summary?: Record<string, unknown>;
+};
+export type VoiceProofAssertionSummary = {
+    failed: number;
+    failures: Array<{
+        name: string;
+        summary?: Record<string, unknown>;
+    }>;
+    ok: boolean;
+    passed: number;
+    total: number;
+};
+export type VoiceProofAssertionInput = {
+    missingIssue?: string;
+    name: string;
+    ok?: boolean;
+    summary?: Record<string, unknown>;
+};
+export type VoiceEvidenceAssertionInput<TEvidence> = {
+    evidence?: TEvidence;
+    missingIssue?: string;
+    name: string;
+    ok?: (evidence: TEvidence) => boolean;
+    summary?: (evidence: TEvidence) => Record<string, unknown>;
+};
+export declare const createVoiceEvidenceAssertion: <TEvidence>(input: VoiceEvidenceAssertionInput<TEvidence>) => VoiceProofAssertionResult;
+export declare const createVoiceProofAssertion: (input: VoiceProofAssertionInput) => VoiceProofAssertionResult;
+export declare const summarizeVoiceProofAssertions: (assertions: VoiceProofAssertionResult[]) => VoiceProofAssertionSummary;

package/dist/core/proofPack.d.ts

@@ -0,0 +1,211 @@
+import { Elysia } from "elysia";
+import { type StoredVoiceAuditEvent, type VoiceAuditEventFilter, type VoiceAuditEventStore } from "./audit";
+import type { VoiceObservabilityExportArtifact, VoiceObservabilityExportReport } from "./observabilityExport";
+import type { VoiceCallDebuggerReport } from "./callDebugger";
+import type { VoiceOperationsRecord } from "./operationsRecord";
+import type { VoiceProductionReadinessReport } from "./productionReadiness";
+import type { VoiceProviderSloReport } from "./providerSlo";
+import type { VoiceSessionObservabilityReport } from "./sessionObservability";
+import type { VoiceSessionSnapshot } from "./sessionSnapshot";
+import { type StoredVoiceTraceEvent, type VoiceTraceEventFilter, type VoiceTraceEventStore, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore } from "./trace";
+export type VoiceProofPackStatus = "fail" | "pass" | "warn";
+export type VoiceProofPackEvidence = {
+    detail?: string;
+    href?: string;
+    label: string;
+    status?: VoiceProofPackStatus;
+    value?: number | string;
+};
+export type VoiceProofPackSection = {
+    evidence?: VoiceProofPackEvidence[];
+    status?: VoiceProofPackStatus;
+    summary?: string;
+    title: string;
+};
+export type VoiceProofPack = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    generatedAt: string;
+    ok: boolean;
+    outputDir?: string;
+    runId: string;
+    sections: VoiceProofPackSection[];
+    status: VoiceProofPackStatus;
+    summary: {
+        fail: number;
+        pass: number;
+        sections: number;
+        warn: number;
+    };
+};
+export type VoiceProofPackInput = {
+    artifacts?: VoiceObservabilityExportArtifact[];
+    callDebuggerReports?: VoiceCallDebuggerReport[];
+    generatedAt?: number | string;
+    observabilityExport?: VoiceObservabilityExportReport;
+    operationsRecords?: VoiceOperationsRecord[];
+    outputDir?: string;
+    productionReadiness?: VoiceProductionReadinessReport;
+    providerSlo?: VoiceProviderSloReport;
+    runId?: string;
+    sections?: VoiceProofPackSection[];
+    sessionObservabilityReports?: VoiceSessionObservabilityReport[];
+    sessionSnapshots?: VoiceSessionSnapshot[];
+};
+export type VoiceProofPackWriteResult = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    jsonPath: string;
+    markdownPath: string;
+    proofPack: VoiceProofPack;
+};
+export type VoiceProofPackBuildTiming = {
+    durationMs: number;
+    endedAt: number;
+    label: string;
+    startedAt: number;
+};
+export type VoiceProofPackBuildContext = {
+    cache: <TValue>(key: string, loader: () => Promise<TValue> | TValue) => Promise<TValue>;
+    clear: (key?: string) => void;
+    getTimings: () => VoiceProofPackBuildTiming[];
+    time: <TValue>(label: string, run: () => Promise<TValue> | TValue) => Promise<TValue>;
+};
+export type VoiceProofPackBuildContextOptions = {
+    now?: () => number;
+    onTiming?: (timing: VoiceProofPackBuildTiming) => void;
+};
+export type VoiceProofRefreshSnapshotOptions = {
+    audit?: VoiceAuditEventStore;
+    auditFilter?: VoiceAuditEventFilter;
+    auditSinkDeliveries?: {
+        list: () => Promise<unknown[]> | unknown[];
+    };
+    events?: StoredVoiceTraceEvent[];
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traceFilter?: VoiceTraceEventFilter;
+    traceStore?: VoiceTraceEventStore;
+};
+export type VoiceProofRefreshSnapshot = {
+    auditEvents: StoredVoiceAuditEvent[];
+    auditStore: VoiceAuditEventStore;
+    auditSinkDeliveries: unknown[];
+    capturedAt: number;
+    traceDeliveries: VoiceTraceSinkDeliveryRecord[];
+    traceDeliveryStore: VoiceTraceSinkDeliveryStore;
+    traceEvents: StoredVoiceTraceEvent[];
+    traceStore: VoiceTraceEventStore;
+};
+export type VoiceProofPackInputBuilderSupportBundle = {
+    callDebuggerReports?: VoiceCallDebuggerReport[];
+    sessionObservabilityReports?: VoiceSessionObservabilityReport[];
+    sessionSnapshots?: VoiceSessionSnapshot[];
+};
+export type VoiceProofPackInputBuilderLoaderInput = {
+    context: VoiceProofPackBuildContext;
+};
+export type VoiceProofPackInputBuilderOperationsLoaderInput = VoiceProofPackInputBuilderLoaderInput & {
+    supportBundle?: VoiceProofPackInputBuilderSupportBundle;
+};
+export type VoiceProofPackInputBuilderOptions = Omit<VoiceProofPackInput, "callDebuggerReports" | "observabilityExport" | "operationsRecords" | "productionReadiness" | "providerSlo" | "sessionObservabilityReports" | "sessionSnapshots"> & {
+    callDebuggerReports?: VoiceCallDebuggerReport[];
+    context?: VoiceProofPackBuildContext;
+    loadObservabilityExport?: (input: VoiceProofPackInputBuilderLoaderInput) => Promise<VoiceObservabilityExportReport> | VoiceObservabilityExportReport;
+    loadOperationsRecords?: (input: VoiceProofPackInputBuilderOperationsLoaderInput) => Promise<VoiceOperationsRecord[]> | VoiceOperationsRecord[];
+    loadProductionReadiness?: (input: VoiceProofPackInputBuilderLoaderInput) => Promise<VoiceProductionReadinessReport> | VoiceProductionReadinessReport;
+    loadProviderSlo?: (input: VoiceProofPackInputBuilderLoaderInput) => Promise<VoiceProviderSloReport> | VoiceProviderSloReport;
+    loadSupportBundle?: (input: VoiceProofPackInputBuilderLoaderInput) => Promise<VoiceProofPackInputBuilderSupportBundle> | VoiceProofPackInputBuilderSupportBundle;
+    operationsRecords?: VoiceOperationsRecord[];
+    sessionObservabilityReports?: VoiceSessionObservabilityReport[];
+    sessionSnapshots?: VoiceSessionSnapshot[];
+};
+export type VoiceProofPackSourceValue = VoiceProofPack | VoiceProofPackInput;
+export type VoiceProofPackStaleWhileRefreshSourceOptions = {
+    maxAgeMs?: number;
+    now?: () => number;
+    onRefreshError?: (error: unknown) => void;
+    read: () => VoiceProofPackSourceValue | Promise<VoiceProofPackSourceValue>;
+    refresh: () => VoiceProofPackSourceValue | void | Promise<VoiceProofPackSourceValue | void>;
+};
+export type VoiceProofPackRefreshState = "failed" | "fresh" | "missing" | "refreshing" | "stale";
+export type VoiceProofPackRefreshStatus = {
+    ageMs?: number;
+    error?: string;
+    generatedAt?: string;
+    lastRefreshCompletedAt?: number;
+    lastRefreshStartedAt?: number;
+    maxAgeMs: number;
+    refreshing: boolean;
+    runId?: string;
+    state: VoiceProofPackRefreshState;
+};
+export type VoiceProofPackStaleWhileRefreshSource = ((...args: []) => Promise<VoiceProofPackSourceValue>) & {
+    getStatus: () => VoiceProofPackRefreshStatus;
+};
+export type VoiceProofPackRoutesOptions = {
+    headers?: HeadersInit;
+    jsonPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    source: VoiceProofPackSourceValue | (() => VoiceProofPackSourceValue | Promise<VoiceProofPackSourceValue>);
+};
+export declare const createVoiceProofPackBuildContext: (options?: VoiceProofPackBuildContextOptions) => VoiceProofPackBuildContext;
+export declare const buildVoiceProofPackInput: (options: VoiceProofPackInputBuilderOptions) => Promise<VoiceProofPackInput>;
+export declare const createVoiceProofRefreshSnapshot: (options?: VoiceProofRefreshSnapshotOptions) => Promise<VoiceProofRefreshSnapshot>;
+export declare const createVoiceProofPackOperationsRecordSection: (records: readonly VoiceOperationsRecord[], options?: {
+    href?: (sessionId: string) => string | undefined;
+    title?: string;
+}) => VoiceProofPackSection;
+export declare const createVoiceProofPackProductionReadinessSection: (report: VoiceProductionReadinessReport, options?: {
+    title?: string;
+}) => VoiceProofPackSection;
+export declare const createVoiceProofPackProviderSloSection: (report: VoiceProviderSloReport, options?: {
+    href?: string;
+    title?: string;
+}) => VoiceProofPackSection;
+export declare const createVoiceProofPackSupportBundleSection: (input: {
+    callDebuggerReports?: readonly VoiceCallDebuggerReport[];
+    sessionObservabilityReports?: readonly VoiceSessionObservabilityReport[];
+    sessionSnapshots?: readonly VoiceSessionSnapshot[];
+    title?: string;
+}) => VoiceProofPackSection;
+export declare const buildVoiceProofPack: (input: VoiceProofPackInput | VoiceProofPack) => VoiceProofPack;
+export declare const buildVoiceProofPackFromObservabilityExport: (report: VoiceObservabilityExportReport, input?: Omit<VoiceProofPackInput, "artifacts" | "sections">) => VoiceProofPack;
+export declare const createVoiceProofPackArtifacts: (input: {
+    jsonPath?: string;
+    markdownPath?: string;
+    proofPack: VoiceProofPack;
+}) => VoiceObservabilityExportArtifact[];
+export declare const createVoiceProofPackRoutes: (options: VoiceProofPackRoutesOptions) => 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 createVoiceProofPackStaleWhileRefreshSource: (options: VoiceProofPackStaleWhileRefreshSourceOptions) => VoiceProofPackStaleWhileRefreshSource;
+export declare const renderVoiceProofPackMarkdown: (proofPack: VoiceProofPack) => string;
+export declare const writeVoiceProofPack: (input: VoiceProofPackInput | VoiceProofPack, options?: {
+    jsonFileName?: string;
+    markdownFileName?: string;
+    outputDir: string;
+}) => Promise<VoiceProofPackWriteResult>;