@absolutejs/voice 0.0.22-beta.5 → 0.0.22-beta.500

package/dist/guardrails.d.ts

@@ -0,0 +1,128 @@
+import { Elysia } from "elysia";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceOnTurnObjectHandler, VoiceRouteResult, VoiceSessionRecord } from "./types";
+import type { VoiceAssistantGuardrails } from "./assistant";
+export type VoiceGuardrailStage = "assistant-output" | "handoff" | "model-input" | "tool-input" | "tool-output" | "transcript";
+export type VoiceGuardrailSeverity = "block" | "warn";
+export type VoiceGuardrailStatus = "blocked" | "pass" | "warn";
+export type VoiceGuardrailRule = {
+    action?: VoiceGuardrailSeverity;
+    description?: string;
+    id: string;
+    label?: string;
+    match: RegExp | string | ((input: VoiceGuardrailEvaluationInput) => boolean | Promise<boolean>);
+    redactWith?: string;
+    stages?: VoiceGuardrailStage[];
+};
+export type VoiceGuardrailEvaluationInput = {
+    content?: unknown;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    turnId?: string;
+};
+export type VoiceGuardrailFinding = {
+    action: VoiceGuardrailSeverity;
+    description?: string;
+    label: string;
+    ruleId: string;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailDecision = {
+    allowed: boolean;
+    checkedAt: number;
+    content?: unknown;
+    findings: VoiceGuardrailFinding[];
+    redactedContent?: unknown;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    status: VoiceGuardrailStatus;
+    turnId?: string;
+};
+export type VoiceGuardrailPolicy = {
+    defaultAction?: VoiceGuardrailSeverity;
+    id: string;
+    label?: string;
+    rules: VoiceGuardrailRule[];
+};
+export type VoiceGuardrailReport = {
+    checkedAt: number;
+    decisions: VoiceGuardrailDecision[];
+    failed: number;
+    policies: Array<{
+        id: string;
+        label?: string;
+        rules: number;
+    }>;
+    status: "fail" | "pass" | "warn";
+    summary: {
+        blocked: number;
+        passed: number;
+        warned: number;
+    };
+    total: number;
+};
+export type VoiceGuardrailRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    policies?: VoiceGuardrailPolicy[];
+    source?: ((input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision | VoiceGuardrailReport> | VoiceGuardrailDecision | VoiceGuardrailReport) | VoiceGuardrailDecision | VoiceGuardrailReport;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntimeBlockInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    decision: VoiceGuardrailDecision;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailRuntimeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    blockResult?: (input: VoiceGuardrailRuntimeBlockInput<TContext, TSession, TResult>) => Promise<VoiceRouteResult<TResult>> | VoiceRouteResult<TResult>;
+    name?: string;
+    policies: VoiceGuardrailPolicy[];
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntime<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistantGuardrails: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    evaluate: (input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+    wrapTool: <TArgs extends Record<string, unknown>, TToolResult>(tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>) => VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>;
+    wrapTools: (tools: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>) => Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+};
+export declare const evaluateVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy, input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+export declare const buildVoiceGuardrailReport: (input?: {
+    decisions: VoiceGuardrailDecision[];
+    policies?: VoiceGuardrailPolicy[];
+}) => VoiceGuardrailReport;
+export declare const createVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy) => VoiceGuardrailPolicy;
+export declare const createVoiceGuardrailRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceGuardrailRuntimeOptions<TContext, TSession, TResult>) => VoiceGuardrailRuntime<TContext, TSession, TResult>;
+export declare const voiceGuardrailPolicyPresets: {
+    supportSafeDefaults: VoiceGuardrailPolicy;
+};
+export declare const renderVoiceGuardrailMarkdown: (report: VoiceGuardrailReport) => string;
+export declare const createVoiceGuardrailRoutes: (options?: VoiceGuardrailRoutesOptions) => 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/handoff.d.ts

@@ -0,0 +1,54 @@
+import type { VoiceHandoffAction, VoiceHandoffAdapter, VoiceHandoffConfig, VoiceHandoffDeliveryStore, VoiceHandoffInput, VoiceHandoffResult, VoiceSessionRecord, StoredVoiceHandoffDelivery } from "./types";
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceHandoffDelivery = VoiceHandoffResult & {
+    adapterId: string;
+    adapterKind?: string;
+};
+export type VoiceHandoffDeliveryRecord<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>;
+export type VoiceHandoffFanoutResult = {
+    action: VoiceHandoffAction;
+    deliveries: Record<string, VoiceHandoffDelivery>;
+    status: VoiceHandoffResult["status"];
+};
+export type VoiceHandoffDeliveryRecordInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceHandoffInput<TContext, TSession, TResult>, "api"> & {
+    id?: string;
+};
+export type VoiceQueuedHandoffDeliveryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    api: VoiceHandoffInput<TContext, TSession, TResult>["api"];
+    delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+    failMode?: VoiceHandoffConfig<TContext, TSession, TResult>["failMode"];
+};
+export type VoiceWebhookHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    actions?: VoiceHandoffAction[];
+    body?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<Record<string, unknown>>;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    id: string;
+    kind?: string;
+    method?: "POST" | "PUT" | "PATCH";
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceTwilioRedirectHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    accountSid: string;
+    actions?: VoiceHandoffAction[];
+    authToken: string;
+    buildTwiML?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string>;
+    callSid?: string | ((input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string | undefined>);
+    fetch?: typeof fetch;
+    id?: string;
+    timeoutMs?: number;
+};
+export declare const deliverVoiceHandoff: <TContext, TSession extends VoiceSessionRecord, TResult>(input: {
+    config?: VoiceHandoffConfig<TContext, TSession, TResult>;
+    handoff: VoiceHandoffInput<TContext, TSession, TResult>;
+}) => Promise<VoiceHandoffFanoutResult | undefined>;
+export declare const createVoiceHandoffDeliveryRecord: <TContext, TSession extends VoiceSessionRecord, TResult>(input: VoiceHandoffDeliveryRecordInput<TContext, TSession, TResult>) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const applyVoiceHandoffDeliveryResult: <TContext, TSession extends VoiceSessionRecord, TResult>(delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>, result: VoiceHandoffFanoutResult) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const deliverVoiceHandoffDelivery: <TContext, TSession extends VoiceSessionRecord, TResult>(options: VoiceQueuedHandoffDeliveryOptions<TContext, TSession, TResult>) => Promise<VoiceHandoffDeliveryRecord<TContext, TSession, TResult>>;
+export declare const createVoiceMemoryHandoffDeliveryStore: <TDelivery extends VoiceHandoffDeliveryRecord = VoiceHandoffDeliveryRecord>() => VoiceHandoffDeliveryStore<TDelivery>;
+export declare const createVoiceWebhookHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceWebhookHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export declare const createVoiceTwilioRedirectHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceTwilioRedirectHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export {};

package/dist/handoffHealth.d.ts

@@ -0,0 +1,94 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceHandoffHealthStatus = "delivered" | "failed" | "skipped";
+export type VoiceHandoffHealthDelivery = {
+    adapterId: string;
+    adapterKind?: string;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    status: VoiceHandoffHealthStatus;
+};
+export type VoiceHandoffHealthEvent = {
+    action?: string;
+    at: number;
+    deliveries: VoiceHandoffHealthDelivery[];
+    reason?: string;
+    replayHref?: string;
+    sessionId: string;
+    status: VoiceHandoffHealthStatus;
+    target?: string;
+};
+export type VoiceHandoffHealthSummary = {
+    byAction: Record<string, number>;
+    byAdapter: Record<string, Record<VoiceHandoffHealthStatus, number>>;
+    byStatus: Record<VoiceHandoffHealthStatus, number>;
+    events: VoiceHandoffHealthEvent[];
+    failed: number;
+    total: number;
+};
+export type VoiceHandoffHealthSummaryOptions = {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    q?: string;
+    replayHref?: false | string | ((event: Omit<VoiceHandoffHealthEvent, "replayHref">) => string);
+    status?: VoiceHandoffHealthStatus | "all";
+    store?: VoiceTraceEventStore;
+};
+export type VoiceHandoffHealthHTMLHandlerOptions = VoiceHandoffHealthSummaryOptions & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceHandoffHealthSummary) => string | Promise<string>;
+};
+export type VoiceHandoffHealthRoutesOptions = VoiceHandoffHealthHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceHandoffHealth: (options?: VoiceHandoffHealthSummaryOptions) => Promise<VoiceHandoffHealthSummary>;
+export declare const renderVoiceHandoffHealthHTML: (summary: VoiceHandoffHealthSummary) => string;
+export declare const createVoiceHandoffHealthJSONHandler: (options?: VoiceHandoffHealthSummaryOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceHandoffHealthSummary>;
+export declare const createVoiceHandoffHealthHTMLHandler: (options?: VoiceHandoffHealthHTMLHandlerOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceHandoffHealthRoutes: (options?: VoiceHandoffHealthRoutesOptions) => 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: VoiceHandoffHealthSummary;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/htmx.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceHTMXConfig, VoiceHTMXRenderConfig, VoiceHTMXRenderInput, VoiceHTMXTargets, VoiceSessionRecord } from './types';
+import type { VoiceHTMXConfig, VoiceHTMXRenderConfig, VoiceHTMXRenderInput, VoiceHTMXTargets, VoiceSessionRecord } from "./types";
 type ResolvedVoiceHTMXRenderConfig<TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Required<VoiceHTMXRenderConfig<TSession, TResult>>;
 export declare const resolveVoiceHTMXTargets: (custom?: Partial<VoiceHTMXTargets>) => VoiceHTMXTargets;
 export declare const resolveVoiceHTMXRenderers: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(custom?: VoiceHTMXConfig<TSession, TResult>) => ResolvedVoiceHTMXRenderConfig<TSession, TResult>;

package/dist/incidentBundle.d.ts

@@ -0,0 +1,119 @@
+import { Elysia } from "elysia";
+import { type VoiceOperationsRecord, type VoiceOperationsRecordOptions } from "./operationsRecord";
+import type { VoiceIncidentRecoveryOutcomeReport } from "./incidentTimeline";
+import { type VoiceTraceRedactionConfig } from "./trace";
+export type VoiceIncidentBundleFormat = "json" | "markdown";
+export type VoiceIncidentBundle = {
+    auditMarkdown?: string;
+    exportedAt: number;
+    formatVersion: 1;
+    markdown: string;
+    record: VoiceOperationsRecord;
+    recoveryOutcomes?: VoiceIncidentRecoveryOutcomeReport;
+    redacted: boolean;
+    sessionId: string;
+    summary: VoiceIncidentBundleSummary;
+    traceMarkdown: string;
+};
+export type StoredVoiceIncidentBundleArtifact = {
+    bundle: VoiceIncidentBundle;
+    createdAt: number;
+    expiresAt?: number;
+    id: string;
+    metadata?: Record<string, unknown>;
+    redacted: boolean;
+    sessionId: string;
+};
+export type VoiceIncidentBundleStoreFilter = {
+    expiredAt?: number;
+    sessionId?: string;
+};
+export type VoiceIncidentBundleStore<TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact> = {
+    get: (id: string) => Promise<TArtifact | undefined> | TArtifact | undefined;
+    list: (filter?: VoiceIncidentBundleStoreFilter) => Promise<TArtifact[]> | TArtifact[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, artifact: TArtifact) => Promise<void> | void;
+};
+export type VoiceIncidentBundleSummary = {
+    auditEvents: number;
+    durationMs?: number;
+    errors: number;
+    handoffs: number;
+    providers: string[];
+    sessionId: string;
+    status: VoiceOperationsRecord["status"];
+    tools: number;
+    traceEvents: number;
+    turns: number;
+};
+export type VoiceIncidentBundleOptions = VoiceOperationsRecordOptions & {
+    redact?: VoiceTraceRedactionConfig;
+    recoveryOutcomes?: VoiceIncidentRecoveryOutcomeReport;
+    title?: string;
+};
+export type VoiceIncidentBundleRoutesOptions = Omit<VoiceIncidentBundleOptions, "sessionId"> & {
+    headers?: HeadersInit;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceIncidentBundleArtifactOptions = {
+    createdAt?: number;
+    expiresAt?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    ttlMs?: number;
+};
+export type VoiceIncidentBundleRetentionOptions = {
+    before?: number;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    expiredAt?: number;
+    keepNewest?: number;
+    limit?: number;
+    store: VoiceIncidentBundleStore;
+};
+export type VoiceIncidentBundleRetentionReport = {
+    deleted: StoredVoiceIncidentBundleArtifact[];
+    deletedCount: number;
+    deletedIds: string[];
+    dryRun: boolean;
+    scannedCount: number;
+};
+export declare const createVoiceMemoryIncidentBundleStore: <TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact>() => VoiceIncidentBundleStore<TArtifact>;
+export declare const createStoredVoiceIncidentBundleArtifact: (bundle: VoiceIncidentBundle, options?: VoiceIncidentBundleArtifactOptions) => StoredVoiceIncidentBundleArtifact;
+export declare const saveVoiceIncidentBundleArtifact: (input: {
+    bundle: VoiceIncidentBundle;
+    options?: VoiceIncidentBundleArtifactOptions;
+    store: VoiceIncidentBundleStore;
+}) => Promise<StoredVoiceIncidentBundleArtifact>;
+export declare const pruneVoiceIncidentBundleArtifacts: (options: VoiceIncidentBundleRetentionOptions) => Promise<VoiceIncidentBundleRetentionReport>;
+export declare const buildVoiceIncidentBundle: (options: VoiceIncidentBundleOptions) => Promise<VoiceIncidentBundle>;
+export declare const createVoiceIncidentBundleRoutes: (options: VoiceIncidentBundleRoutesOptions) => 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/incidentTimeline.d.ts

@@ -0,0 +1,260 @@
+import { Elysia } from "elysia";
+import type { VoiceFailureReplayReport, VoiceOperationsRecord } from "./operationsRecord";
+import type { VoiceOperationalStatusReport } from "./operationalStatus";
+import type { VoiceOpsRecoveryReport } from "./opsRecovery";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+import type { VoiceAuditEventStore } from "./audit";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceMonitorIssue } from "./voiceMonitoring";
+export type VoiceIncidentTimelineStatus = "fail" | "pass" | "warn";
+export type VoiceIncidentTimelineSeverity = "critical" | "info" | "warn";
+export type VoiceIncidentTimelineAction = {
+    href?: string;
+    label: string;
+    method?: "GET" | "POST";
+};
+export type VoiceIncidentRecoveryAction = {
+    detail?: string;
+    disabled?: boolean;
+    eventId?: string;
+    href?: string;
+    id: string;
+    label: string;
+    method?: "GET" | "POST";
+    sessionId?: string;
+};
+export type VoiceIncidentRecoveryActionResult = {
+    actionId: string;
+    afterStatus?: VoiceIncidentTimelineStatus;
+    beforeStatus?: VoiceIncidentTimelineStatus;
+    detail?: string;
+    href?: string;
+    ok: boolean;
+    status?: string;
+};
+export type VoiceIncidentRecoveryActionHandlerInput = {
+    action: VoiceIncidentRecoveryAction;
+    actionId: string;
+    report: VoiceIncidentTimelineReport;
+    request: Request;
+};
+export type VoiceIncidentRecoveryActionHandler = (input: VoiceIncidentRecoveryActionHandlerInput) => Promise<VoiceIncidentRecoveryActionResult> | VoiceIncidentRecoveryActionResult;
+export type VoiceIncidentRecoveryOutcome = "failed" | "improved" | "regressed" | "unchanged";
+export type VoiceIncidentRecoveryOutcomeEntry = {
+    actionId: string;
+    afterStatus?: VoiceIncidentTimelineStatus;
+    at: number;
+    beforeStatus?: VoiceIncidentTimelineStatus;
+    detail?: string;
+    eventId: string;
+    outcome: VoiceIncidentRecoveryOutcome;
+    status?: number;
+    traceId?: string;
+};
+export type VoiceIncidentRecoveryOutcomeReport = {
+    checkedAt: number;
+    entries: VoiceIncidentRecoveryOutcomeEntry[];
+    failed: number;
+    improved: number;
+    regressed: number;
+    total: number;
+    unchanged: number;
+};
+export type VoiceIncidentRecoveryTrendStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceIncidentRecoveryTrendSloMode = "aggregate" | "latest";
+export type VoiceIncidentRecoveryTrendSloOptions = {
+    href?: string;
+    label?: string;
+    maxFailureRate?: number;
+    maxRegressionRate?: number;
+    maxUnchangedRate?: number;
+    minActions?: number;
+    minCycles?: number;
+    minImprovementRate?: number;
+    warnWhenEmpty?: boolean;
+    mode?: VoiceIncidentRecoveryTrendSloMode;
+};
+export type VoiceIncidentRecoveryTrendCycle = {
+    checkedAt: number;
+    failed: number;
+    failureRate: number;
+    improved: number;
+    improvementRate: number;
+    regressed: number;
+    regressionRate: number;
+    total: number;
+    unchanged: number;
+    unchangedRate: number;
+};
+export type VoiceIncidentRecoveryTrendReport = {
+    checkedAt: number;
+    cycles: VoiceIncidentRecoveryTrendCycle[];
+    latest?: VoiceIncidentRecoveryTrendCycle;
+    previous?: VoiceIncidentRecoveryTrendCycle;
+    status: VoiceIncidentRecoveryTrendStatus;
+    summary: {
+        cycles: number;
+        failed: number;
+        failureRate: number;
+        improved: number;
+        improvementRate: number;
+        regressed: number;
+        regressionRate: number;
+        total: number;
+        unchanged: number;
+        unchangedRate: number;
+    };
+    trend: {
+        failureRateDelta?: number;
+        improvementRateDelta?: number;
+        regressionRateDelta?: number;
+        unchangedRateDelta?: number;
+    };
+};
+export type VoiceIncidentRecoveryOutcomeOptions = {
+    audit?: VoiceAuditEventStore;
+    limit?: number;
+};
+export type VoiceIncidentRecoveryOutcomeReadinessOptions = {
+    failOnFailed?: boolean;
+    failOnRegressed?: boolean;
+    href?: string;
+    label?: string;
+    maxUnchanged?: number;
+    warnWhenEmpty?: boolean;
+};
+export type VoiceIncidentTimelineEvent = {
+    action?: VoiceIncidentTimelineAction;
+    at: number;
+    category: "call" | "delivery" | "failure-replay" | "monitor" | "operational-status" | "readiness" | "recovery";
+    detail?: string;
+    href?: string;
+    id: string;
+    label: string;
+    sessionId?: string;
+    severity: VoiceIncidentTimelineSeverity;
+    source: string;
+    value?: number | string;
+};
+export type VoiceIncidentTimelineReport = {
+    actions: VoiceIncidentRecoveryAction[];
+    events: VoiceIncidentTimelineEvent[];
+    generatedAt: number;
+    links: VoiceIncidentTimelineLinks;
+    status: VoiceIncidentTimelineStatus;
+    summary: {
+        critical: number;
+        info: number;
+        total: number;
+        warn: number;
+    };
+    windowMs?: number;
+};
+export type VoiceIncidentTimelineValue<TValue> = TValue | (() => Promise<TValue> | TValue);
+export type VoiceIncidentTimelineLinks = {
+    callDebugger?: string | ((sessionId: string) => string);
+    deliveryRuntime?: string;
+    failureReplay?: string | ((sessionId: string) => string);
+    monitorIssues?: string;
+    operationalStatus?: string;
+    operationsRecords?: string | ((sessionId: string) => string);
+    productionReadiness?: string;
+    proofPack?: string;
+    supportBundle?: string | ((sessionId: string) => string);
+};
+export type VoiceIncidentTimelineOptions = {
+    extraEvents?: VoiceIncidentTimelineValue<readonly VoiceIncidentTimelineEvent[]>;
+    failureReplays?: VoiceIncidentTimelineValue<readonly VoiceFailureReplayReport[]>;
+    links?: VoiceIncidentTimelineLinks;
+    limit?: number;
+    monitorIssues?: VoiceIncidentTimelineValue<readonly VoiceMonitorIssue[]>;
+    now?: number;
+    operationalStatus?: VoiceIncidentTimelineValue<VoiceOperationalStatusReport>;
+    operationsRecords?: VoiceIncidentTimelineValue<readonly VoiceOperationsRecord[]>;
+    opsRecovery?: VoiceIncidentTimelineValue<VoiceOpsRecoveryReport>;
+    recoveryActions?: readonly VoiceIncidentRecoveryAction[] | ((input: {
+        events: readonly VoiceIncidentTimelineEvent[];
+        report: Omit<VoiceIncidentTimelineReport, "actions">;
+    }) => Promise<readonly VoiceIncidentRecoveryAction[]> | readonly VoiceIncidentRecoveryAction[]);
+    windowMs?: number;
+};
+export type VoiceIncidentTimelineRoutesOptions = VoiceIncidentTimelineOptions & {
+    actionHandlers?: Record<string, VoiceIncidentRecoveryActionHandler>;
+    actionPath?: false | string;
+    audit?: VoiceAuditEventStore;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceIncidentTimelineReport) => string | Promise<string>;
+    recoveryOutcomeHtmlPath?: false | string;
+    recoveryOutcomePath?: false | string;
+    recoveryTrendHtmlPath?: false | string;
+    recoveryTrendMarkdownPath?: false | string;
+    recoveryTrendPath?: false | string;
+    recoveryTrendReports?: VoiceIncidentRecoveryOutcomeReport[] | (() => VoiceIncidentRecoveryOutcomeReport[] | Promise<VoiceIncidentRecoveryOutcomeReport[]>);
+    title?: string;
+    trace?: VoiceTraceEventStore;
+};
+export declare const buildVoiceIncidentRecoveryOutcomeReport: (options: VoiceIncidentRecoveryOutcomeOptions) => Promise<VoiceIncidentRecoveryOutcomeReport>;
+export declare const renderVoiceIncidentRecoveryOutcomeHTML: (report: VoiceIncidentRecoveryOutcomeReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceIncidentRecoveryOutcomeReadinessCheck: (report: VoiceIncidentRecoveryOutcomeReport, options?: VoiceIncidentRecoveryOutcomeReadinessOptions) => VoiceProductionReadinessCheck;
+export declare const buildVoiceIncidentRecoveryTrendSLOReadinessCheck: (report: VoiceIncidentRecoveryTrendReport, options?: VoiceIncidentRecoveryTrendSloOptions) => VoiceProductionReadinessCheck;
+export declare const buildVoiceIncidentRecoveryTrendReport: (reports?: readonly VoiceIncidentRecoveryOutcomeReport[]) => VoiceIncidentRecoveryTrendReport;
+export declare const renderVoiceIncidentRecoveryTrendMarkdown: (report: VoiceIncidentRecoveryTrendReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceIncidentRecoveryTrendHTML: (report: VoiceIncidentRecoveryTrendReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceIncidentTimelineReport: (options: VoiceIncidentTimelineOptions) => Promise<VoiceIncidentTimelineReport>;
+export declare const renderVoiceIncidentTimelineMarkdown: (report: VoiceIncidentTimelineReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceIncidentTimelineHTML: (report: VoiceIncidentTimelineReport, options?: {
+    actionPath?: string;
+    title?: string;
+}) => string;
+export declare const createVoiceIncidentTimelineRoutes: (options: VoiceIncidentTimelineRoutesOptions) => 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: {};
+}>;