@absolutejs/voice 0.0.22-beta.29 → 0.0.22-beta.291

package/dist/types.d.ts

@@ -3,6 +3,7 @@ import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRule, Voice
 import type { VoiceIntegrationSink } from './opsSinks';
 import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
 import type { VoiceTraceEventStore } from './trace';
+import type { VoiceLiveOpsControlState } from './liveOps';
 export type AudioFormat = {
     container: 'raw';
     encoding: 'alaw' | 'mulaw' | 'pcm_s16le';
@@ -193,6 +194,15 @@ export type RealtimeAdapter<TOptions extends RealtimeAdapterOpenOptions = Realti
     open: (options: TOptions) => Promise<RealtimeAdapterSession> | RealtimeAdapterSession;
 };
 export type VoiceSessionStatus = 'active' | 'reconnecting' | 'completed' | 'failed';
+export type VoiceReconnectClientStatus = 'idle' | 'reconnecting' | 'resumed' | 'exhausted';
+export type VoiceReconnectClientState = {
+    attempts: number;
+    lastDisconnectAt?: number;
+    lastResumedAt?: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    status: VoiceReconnectClientStatus;
+};
 export type VoiceTurnRecord<TResult = unknown> = {
     id: string;
     text: string;
@@ -278,6 +288,34 @@ export type VoiceHandoffResult = {
     metadata?: Record<string, unknown>;
     status: VoiceHandoffStatus;
 };
+export type VoiceHandoffDeliveryQueueStatus = VoiceHandoffStatus | 'pending';
+export type StoredVoiceHandoffDelivery<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    action: VoiceHandoffAction;
+    context: TContext;
+    createdAt: number;
+    deliveredAt?: number;
+    deliveries?: Record<string, VoiceHandoffResult & {
+        adapterId: string;
+        adapterKind?: string;
+    }>;
+    deliveryAttempts?: number;
+    deliveryError?: string;
+    deliveryStatus: VoiceHandoffDeliveryQueueStatus;
+    id: string;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    result?: TResult;
+    session: TSession;
+    sessionId: string;
+    target?: string;
+    updatedAt: number;
+};
+export type VoiceHandoffDeliveryStore<TDelivery extends StoredVoiceHandoffDelivery = StoredVoiceHandoffDelivery> = {
+    get: (id: string) => Promise<TDelivery | undefined> | TDelivery | undefined;
+    list: () => Promise<TDelivery[]> | TDelivery[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, delivery: TDelivery) => Promise<void> | void;
+};
 export type VoiceHandoffInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     action: VoiceHandoffAction;
     api: VoiceSessionHandle<TContext, TSession, TResult>;
@@ -296,6 +334,8 @@ export type VoiceHandoffAdapter<TContext = unknown, TSession extends VoiceSessio
 };
 export type VoiceHandoffConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    deliveryQueue?: VoiceHandoffDeliveryStore<StoredVoiceHandoffDelivery<TContext, TSession, TResult>>;
+    enqueueOnly?: boolean;
     failMode?: 'record' | 'throw';
 };
 export type VoiceSessionStore<TSession extends VoiceSessionRecord = VoiceSessionRecord> = SessionStore<TSession, VoiceSessionSummary>;
@@ -445,6 +485,10 @@ export type VoiceLexiconResolver<TContext = unknown> = (input: {
 }) => Promise<VoiceLexiconEntry[] | void> | VoiceLexiconEntry[] | void;
 export type VoiceOnTurnObjectHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: {
     context: TContext;
+    liveOps?: {
+        control: VoiceLiveOpsControlState;
+        injectedInstruction?: string;
+    };
     session: TSession;
     turn: VoiceTurnRecord;
     api: VoiceSessionHandle<TContext, TSession, TResult>;
@@ -566,6 +610,9 @@ export type VoiceRuntimeOpsConfig<TContext = unknown, TSession extends VoiceSess
     tasks?: VoiceOpsTaskStore;
     webhook?: VoiceIntegrationWebhookConfig;
 };
+export type VoiceLiveOpsRuntimeConfig = {
+    getControl: (sessionId: string) => Promise<VoiceLiveOpsControlState | null | undefined> | VoiceLiveOpsControlState | null | undefined;
+};
 export type VoiceNormalizedRouteConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceRouteConfig<TContext, TSession, TResult>, 'onTurn'> & {
     onTurn: VoiceOnTurnObjectHandler<TContext, TSession, TResult>;
 };
@@ -586,9 +633,11 @@ export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionR
     lexicon?: VoiceLexiconEntry[] | VoiceLexiconResolver<TContext>;
     phraseHints?: VoicePhraseHint[] | VoicePhraseHintResolver<TContext>;
     preset?: VoiceRuntimePreset;
-    stt: STTAdapter;
+    stt?: STTAdapter;
     sttFallback?: VoiceSTTFallbackConfig;
     sttLifecycle?: VoiceSTTLifecycle;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
     tts?: TTSAdapter;
     session: VoiceSessionStore<NoInfer<TSession>>;
     reconnect?: VoiceReconnectConfig;
@@ -598,6 +647,7 @@ export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionR
     htmx?: boolean | VoiceHTMXConfig<TSession, NoInfer<TResult>>;
     handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    liveOps?: VoiceLiveOpsRuntimeConfig;
     trace?: VoiceTraceEventStore;
 } & VoiceRouteConfig<TContext, TSession, TResult>;
 export type CreateVoiceSessionOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
@@ -605,7 +655,9 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     id: string;
     context: TContext;
     socket: VoiceSocket;
-    stt: STTAdapter;
+    stt?: STTAdapter;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
     tts?: TTSAdapter;
     languageStrategy?: VoiceLanguageStrategy;
     lexicon?: VoiceLexiconEntry[];
@@ -619,6 +671,7 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     turnDetection: VoiceResolvedTurnDetectionConfig;
     audioConditioning?: VoiceResolvedAudioConditioningConfig;
     handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
+    liveOps?: VoiceLiveOpsRuntimeConfig;
     route: VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
     logger?: VoiceLogger;
 };
@@ -652,6 +705,16 @@ export type VoiceServerSessionMessage = {
     status: VoiceSessionStatus;
     scenarioId?: string;
 };
+export type VoiceServerReplayMessage<TResult = unknown> = {
+    type: 'replay';
+    assistantTexts: string[];
+    call?: VoiceCallLifecycleState;
+    partial: string;
+    scenarioId?: string;
+    sessionId: string;
+    status: VoiceSessionStatus;
+    turns: VoiceTurnRecord<TResult>[];
+};
 export type VoiceServerPartialMessage = {
     type: 'partial';
     transcript: Transcript;
@@ -693,17 +756,23 @@ export type VoiceServerErrorMessage = {
 export type VoiceServerPongMessage = {
     type: 'pong';
 };
-export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCallLifecycleMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
+export type VoiceServerConnectionMessage = {
+    type: 'connection';
+    reconnect: VoiceReconnectClientState;
+};
+export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerReplayMessage<TResult> | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCallLifecycleMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage | VoiceServerConnectionMessage;
 export type VoiceConnectionOptions = {
     protocols?: string[];
     scenarioId?: string;
     reconnect?: boolean;
+    reconnectReportPath?: string;
     maxReconnectAttempts?: number;
     pingInterval?: number;
     sessionId?: string;
 };
 export type VoiceCaptureOptions = {
     channelCount?: 1 | 2;
+    onAudio?: (audio: Uint8Array | ArrayBuffer, sendAudio: (audio: Uint8Array | ArrayBuffer) => void) => void;
     onLevel?: (level: number) => void;
     sampleRateHz?: number;
 };
@@ -717,6 +786,46 @@ export type VoiceBargeInOptions = {
     enabled?: boolean;
     interruptOnPartial?: boolean;
     interruptThreshold?: number;
+    monitor?: VoiceBargeInMonitor;
+};
+export type VoiceBargeInTriggerReason = 'input-level' | 'manual-audio' | 'manual-interrupt' | 'partial-transcript';
+export type VoiceBargeInMonitorEvent = {
+    at: number;
+    id: string;
+    latencyMs?: number;
+    playbackStopLatencyMs?: number;
+    reason: VoiceBargeInTriggerReason;
+    sessionId?: string | null;
+    status: 'requested' | 'stopped' | 'skipped';
+    thresholdMs?: number;
+};
+export type VoiceBargeInMonitorSnapshot = {
+    averageLatencyMs?: number;
+    events: VoiceBargeInMonitorEvent[];
+    failed: number;
+    lastEvent?: VoiceBargeInMonitorEvent;
+    passed: number;
+    status: 'empty' | 'fail' | 'pass' | 'warn';
+    thresholdMs: number;
+    total: number;
+};
+export type VoiceBargeInMonitor = {
+    getSnapshot: () => VoiceBargeInMonitorSnapshot;
+    recordRequested: (input: {
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    recordSkipped: (input: {
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    recordStopped: (input: {
+        latencyMs?: number;
+        playbackStopLatencyMs?: number;
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    subscribe: (subscriber: () => void) => () => void;
 };
 export type VoiceAudioPlayerOptions = {
     autoStart?: boolean;
@@ -775,6 +884,7 @@ export type VoiceStreamState<TResult = unknown> = {
     sessionId: string | null;
     scenarioId: string | null;
     status: VoiceSessionStatus | 'idle';
+    reconnect: VoiceReconnectClientState;
     partial: string;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
@@ -801,6 +911,7 @@ export type VoiceStream<TResult = unknown> = {
     getSnapshot: () => VoiceStreamState<TResult>;
     isConnected: boolean;
     partial: string;
+    reconnect: VoiceReconnectClientState;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     sessionId: string | null;
     scenarioId: string | null;
@@ -870,6 +981,7 @@ export type VoiceController<TResult = unknown> = {
     isConnected: boolean;
     isRecording: boolean;
     partial: string;
+    reconnect: VoiceReconnectClientState;
     recordingError: string | null;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     sessionId: string | null;
@@ -903,6 +1015,15 @@ export type VoiceStoreAction<TResult = unknown> = {
     sessionId: string;
     scenarioId?: string;
     status: VoiceSessionStatus;
+} | {
+    type: 'replay';
+    assistantTexts: string[];
+    call?: VoiceCallLifecycleState;
+    partial: string;
+    scenarioId?: string;
+    sessionId: string;
+    status: VoiceSessionStatus;
+    turns: VoiceTurnRecord<TResult>[];
 } | {
     type: 'call_lifecycle';
     event: VoiceCallLifecycleEvent;
@@ -933,6 +1054,9 @@ export type VoiceStoreAction<TResult = unknown> = {
     message: string;
 } | {
     type: 'connected';
+} | {
+    type: 'connection';
+    reconnect: VoiceReconnectClientState;
 } | {
     type: 'disconnected';
 };

package/dist/voiceMonitoring.d.ts

@@ -0,0 +1,444 @@
+import { Elysia } from 'elysia';
+export type VoiceMonitorStatus = 'fail' | 'pass' | 'warn';
+export type VoiceMonitorSeverity = 'critical' | 'info' | 'warn';
+export type VoiceMonitorIssueStatus = 'acknowledged' | 'muted' | 'open' | 'resolved';
+export type VoiceMonitorEvaluationInput<TEvidence = unknown> = {
+    evidence: TEvidence;
+    now: number;
+};
+export type VoiceMonitorEvaluation = {
+    detail?: string;
+    impactedSessions?: readonly string[];
+    operationsRecordHrefs?: readonly string[];
+    status: VoiceMonitorStatus;
+    threshold?: number | string;
+    value?: number | string;
+};
+export type VoiceMonitorDefinition<TEvidence = unknown> = {
+    description?: string;
+    id: string;
+    label: string;
+    severity?: VoiceMonitorSeverity;
+    windowMs?: number;
+    evaluate: (input: VoiceMonitorEvaluationInput<TEvidence>) => Promise<VoiceMonitorEvaluation> | VoiceMonitorEvaluation;
+};
+export type VoiceMonitorRun = VoiceMonitorEvaluation & {
+    checkedAt: number;
+    description?: string;
+    id: string;
+    label: string;
+    severity: VoiceMonitorSeverity;
+    windowMs?: number;
+};
+export type VoiceMonitorIssue = {
+    acknowledgedAt?: number;
+    acknowledgedBy?: string;
+    createdAt: number;
+    detail?: string;
+    id: string;
+    impactedSessions: string[];
+    label: string;
+    lastSeenAt: number;
+    monitorId: string;
+    mutedAt?: number;
+    mutedBy?: string;
+    operationsRecordHrefs: string[];
+    resolvedAt?: number;
+    resolvedBy?: string;
+    severity: VoiceMonitorSeverity;
+    status: VoiceMonitorIssueStatus;
+    threshold?: number | string;
+    value?: number | string;
+};
+export type VoiceMonitorIssueStore = {
+    list: () => Promise<VoiceMonitorIssue[]> | VoiceMonitorIssue[];
+    upsert: (issue: VoiceMonitorIssue) => Promise<VoiceMonitorIssue> | VoiceMonitorIssue;
+    update: (id: string, patch: Partial<VoiceMonitorIssue>) => Promise<VoiceMonitorIssue | undefined> | VoiceMonitorIssue | undefined;
+};
+export type VoiceMonitorNotifier = {
+    deliver: (input: VoiceMonitorNotifierDeliveryInput) => Promise<VoiceMonitorNotifierDeliveryResult> | VoiceMonitorNotifierDeliveryResult;
+    id: string;
+    label: string;
+};
+export type VoiceMonitorNotifierDeliveryInput = {
+    issue: VoiceMonitorIssue;
+    now: number;
+};
+export type VoiceMonitorNotifierDeliveryResult = {
+    detail?: string;
+    status: 'failed' | 'sent' | 'skipped';
+};
+export type VoiceMonitorNotifierDeliveryReceipt = {
+    detail?: string;
+    id: string;
+    issueId: string;
+    notifierId: string;
+    notifierLabel: string;
+    sentAt: number;
+    status: 'failed' | 'sent' | 'skipped';
+};
+export type VoiceMonitorNotifierDeliveryReceiptStore = {
+    list: () => Promise<VoiceMonitorNotifierDeliveryReceipt[]> | VoiceMonitorNotifierDeliveryReceipt[];
+    set: (id: string, receipt: VoiceMonitorNotifierDeliveryReceipt) => Promise<VoiceMonitorNotifierDeliveryReceipt> | VoiceMonitorNotifierDeliveryReceipt;
+};
+export type VoiceMonitorNotifierDeliveryReport = {
+    checkedAt: number;
+    elapsedMs: number;
+    receipts: VoiceMonitorNotifierDeliveryReceipt[];
+    status: VoiceMonitorStatus;
+    summary: {
+        failed: number;
+        notifiers: number;
+        sent: number;
+        skipped: number;
+        total: number;
+    };
+};
+export type VoiceMonitorRunReport = {
+    checkedAt: number;
+    elapsedMs: number;
+    issues: VoiceMonitorIssue[];
+    runs: VoiceMonitorRun[];
+    status: VoiceMonitorStatus;
+    summary: {
+        acknowledged: number;
+        criticalOpen: number;
+        failed: number;
+        muted: number;
+        open: number;
+        passed: number;
+        resolved: number;
+        total: number;
+        warned: number;
+    };
+};
+export type VoiceMonitorRunOptions<TEvidence = unknown> = {
+    evidence: TEvidence;
+    issueStore?: VoiceMonitorIssueStore;
+    monitors: readonly VoiceMonitorDefinition<TEvidence>[];
+    now?: number;
+};
+export type VoiceMonitorNotifierDeliveryOptions = {
+    issueStore: VoiceMonitorIssueStore;
+    notifiers: readonly VoiceMonitorNotifier[];
+    now?: number;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+    statuses?: readonly VoiceMonitorIssueStatus[];
+};
+export type VoiceMonitorWebhookNotifierOptions = {
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+    id: string;
+    label?: string;
+    mapIssue?: (issue: VoiceMonitorIssue) => unknown;
+    url: string;
+};
+export type VoiceMonitorRoutesOptions<TEvidence = unknown> = VoiceMonitorRunOptions<TEvidence> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    issuePath?: string;
+    name?: string;
+    notifierPath?: false | string;
+    notifiers?: readonly VoiceMonitorNotifier[];
+    path?: string;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+    render?: (report: VoiceMonitorRunReport) => Promise<string> | string;
+    title?: string;
+};
+export type VoiceMonitorRunnerTickResult = {
+    completedAt: number;
+    monitoring: VoiceMonitorRunReport;
+    notifierDelivery?: VoiceMonitorNotifierDeliveryReport;
+    startedAt: number;
+};
+export type VoiceMonitorRunner = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceMonitorRunnerTickResult>;
+};
+export type VoiceMonitorRunnerOptions<TEvidence = unknown> = {
+    evidence?: TEvidence;
+    issueStore?: VoiceMonitorIssueStore;
+    loadEvidence?: () => Promise<TEvidence> | TEvidence;
+    monitors: readonly VoiceMonitorDefinition<TEvidence>[];
+    notifiers?: readonly VoiceMonitorNotifier[];
+    now?: () => number;
+    pollIntervalMs?: number;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+};
+export type VoiceMonitorRunnerRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    runner: VoiceMonitorRunner;
+};
+export declare const createVoiceMemoryMonitorIssueStore: (initial?: readonly VoiceMonitorIssue[]) => VoiceMonitorIssueStore;
+export declare const createVoiceMemoryMonitorNotifierDeliveryReceiptStore: (initial?: readonly VoiceMonitorNotifierDeliveryReceipt[]) => VoiceMonitorNotifierDeliveryReceiptStore;
+export declare const buildVoiceMonitorRunReport: <TEvidence = unknown>(options: VoiceMonitorRunOptions<TEvidence>) => Promise<VoiceMonitorRunReport>;
+export declare const acknowledgeVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const resolveVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const muteVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const createVoiceMonitorWebhookNotifier: (options: VoiceMonitorWebhookNotifierOptions) => VoiceMonitorNotifier;
+export declare const deliverVoiceMonitorIssueNotifications: (options: VoiceMonitorNotifierDeliveryOptions) => Promise<VoiceMonitorNotifierDeliveryReport>;
+export declare const createVoiceMonitorRunner: <TEvidence = unknown>(options: VoiceMonitorRunnerOptions<TEvidence>) => VoiceMonitorRunner;
+export declare const renderVoiceMonitorMarkdown: (report: VoiceMonitorRunReport) => string;
+export declare const renderVoiceMonitorHTML: (report: VoiceMonitorRunReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceMonitorRoutes: <TEvidence = unknown>(options: VoiceMonitorRoutesOptions<TEvidence>) => 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: VoiceMonitorRunReport;
+            };
+        };
+    };
+} & {
+    [x: `${string}.md`]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceMonitorIssue[];
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        notifications: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: VoiceMonitorNotifierDeliveryReceipt[];
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            acknowledge: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            resolve: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            mute: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceMonitorRunnerRoutes: (options: VoiceMonitorRunnerRoutesOptions) => 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: {
+                    isRunning: boolean;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        tick: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: VoiceMonitorRunnerTickResult;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        start: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        isRunning: boolean;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        stop: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        isRunning: boolean;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;