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

package/dist/htmxDashboardRoutes.d.ts

@@ -0,0 +1,249 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { LiveCallViewer } from "./client/liveCallViewer";
+import { type VoiceDashboardHTMXRendererConfig } from "./client/htmxDashboardRenderers";
+import type { VoiceCostDashboardOptions } from "./client/costDashboard";
+export type VoiceHTMXDashboardRoutesShared = {
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+};
+export type VoiceHTMXCostDashboardRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    bucketBy?: VoiceCostDashboardOptions["bucketBy"];
+    currency?: string;
+    fromMs?: () => number | undefined;
+    path?: string;
+    pollIntervalMs?: number;
+    resolveEvents: () => Promise<ReadonlyArray<StoredVoiceTraceEvent>> | ReadonlyArray<StoredVoiceTraceEvent>;
+    title?: string;
+    toMs?: () => number | undefined;
+};
+export declare const createVoiceCostDashboardHTMXRoute: (options: VoiceHTMXCostDashboardRoutesOptions) => 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: {};
+}>;
+export type VoiceHTMXReplayTimelineRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** The HTML route mounts at `${path}/:artifactId`. */
+    path?: string;
+    resolveArtifact: (artifactId: string) => Promise<StoredVoiceCallReviewArtifact | undefined> | StoredVoiceCallReviewArtifact | undefined;
+    title?: string;
+};
+export declare const createVoiceReplayTimelineHTMXRoute: (options: VoiceHTMXReplayTimelineRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":artifactId": {
+            get: {
+                body: unknown;
+                params: {
+                    artifactId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    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 type VoiceHTMXLiveCallViewerRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** Route mounts at `${path}/:sessionId`. */
+    path?: string;
+    pollIntervalMs?: number;
+    resolveViewer: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    title?: string;
+};
+export declare const createVoiceLiveCallViewerHTMXRoute: (options: VoiceHTMXLiveCallViewerRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":sessionId": {
+            get: {
+                body: unknown;
+                params: {
+                    sessionId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    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 type VoiceHTMXDashboardRoutesOptions = {
+    cost?: Omit<VoiceHTMXCostDashboardRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    liveCall?: Omit<VoiceHTMXLiveCallViewerRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+    replay?: Omit<VoiceHTMXReplayTimelineRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+};
+export declare const createVoiceHTMXDashboardRoutes: (options: VoiceHTMXDashboardRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type CreateVoiceHTMXDashboardRoutesFromStoresOptions = {
+    liveViewerByCallId?: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    pollIntervalMs?: number;
+    render?: VoiceDashboardHTMXRendererConfig;
+    reviewStore?: VoiceCallReviewStore;
+    traceStore?: VoiceTraceEventStore;
+};
+export declare const createVoiceHTMXDashboardRoutesFromStores: (options: CreateVoiceHTMXDashboardRoutesFromStoresOptions) => 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/iceServers.d.ts

@@ -0,0 +1,34 @@
+export type VoiceIceServer = {
+    credential?: string;
+    urls: string | string[];
+    username?: string;
+};
+export type CreateCoturnIceServersInput = {
+    /** TURN realm. */
+    realm: string;
+    /** Credential TTL in seconds. Default 3600. */
+    ttlSec?: number;
+    /** Coturn shared secret (use_auth_secret). */
+    sharedSecret: string;
+    /** TURN endpoint host:port (e.g. 'turn.example.com:3478'). */
+    turnHost: string;
+    /** Username to derive ephemeral credential for. */
+    username: string;
+    /** Optional STUN endpoints to prepend. Default ['stun:stun.l.google.com:19302']. */
+    stunUrls?: string[];
+    /** UTC unix-seconds NOW override for testing. */
+    now?: number;
+    /** SHA-1 HMAC implementation for testing. Defaults to crypto.subtle. */
+    hmacSha1Base64?: (key: string, message: string) => Promise<string>;
+};
+/**
+ * Builds an iceServers array using the coturn `use-auth-secret` REST API
+ * pattern: username = `${expires}:${callerId}`, credential = HMAC-SHA1(secret, username) base64-encoded.
+ */
+export declare const createCoturnIceServers: (input: CreateCoturnIceServersInput) => Promise<VoiceIceServer[]>;
+export type CreateTwilioNTSIceServersInput = {
+    accountSid: string;
+    authToken: string;
+    fetch?: typeof fetch;
+};
+export declare const createTwilioNTSIceServers: (input: CreateTwilioNTSIceServersInput) => Promise<VoiceIceServer[]>;

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: {};
+}>;