# Dictum SDK public API report v1

This file is generated deterministically from every declaration shipped by the npm package.

## core/browser-compatibility.d.ts

import type { DictumCompatibilityDetails, DictumSttCompatibilityError } from '../shared/index.js';
import type { DictumAudioCaptureAdapter } from './types.js';
/** Checks capabilities used by the selected SDK path. It never sniffs a UA or browser version. */
export declare function inspectBrowserCompatibility(audioCapture?: DictumAudioCaptureAdapter): DictumCompatibilityDetails;
export declare function createBrowserCompatibilityError(details: DictumCompatibilityDetails): DictumSttCompatibilityError;
## core/config-error.d.ts

export declare class DictumConfigError extends Error {
    code: string | undefined;
    status: number | undefined;
    rid: string | undefined;
    exact_message: string | undefined;
    details: unknown;
    raw: unknown;
    constructor(message: string, options?: {
        code?: string;
        status?: number;
        rid?: string;
        exact_message?: string;
        details?: unknown;
        raw?: unknown;
    });
}
## core/config.d.ts

import { type SdkConfigResponse } from '../shared/index.js';
export declare function validateSdkConfigResponse(value: unknown): SdkConfigResponse;
export declare function validateSdkConfigSuccessEnvelope(value: unknown): SdkConfigResponse;
export declare function loadConfig(apiBaseUrl: string, projectKey: string, identityToken: string, signal?: AbortSignal): Promise<SdkConfigResponse>;
## core/diagnostic-sanitizer.d.ts

export declare function safeClone<T>(value: T): T;
## core/diagnostics.d.ts

import type { DictumDiagnosticCode, DictumDiagnosticError, DictumDiagnosticEvent, DictumSessionPhase, DictumSdkDiagnostics, DictumSdkState, SdkRuntime } from './types.js';
export { safeClone } from './diagnostic-sanitizer.js';
export declare function createInitialDiagnostics(projectKey: string): DictumSdkDiagnostics;
export declare function normalizeDiagnosticError(code: DictumDiagnosticCode, error: unknown, sessionId?: string): DictumDiagnosticError;
export declare function recordDiagnosticError(runtime: SdkRuntime, code: DictumDiagnosticCode, error: unknown, sessionId?: string): DictumDiagnosticError;
export declare function appendDiagnostic(runtime: SdkRuntime, event: Omit<DictumDiagnosticEvent, 'at'>): void;
export declare function updateSessionDiagnostics(runtime: SdkRuntime, session: {
    id: string;
    state: DictumSdkState;
    phase: DictumSessionPhase;
    fieldType: string;
    createdAt?: number;
    recordingStartedAt?: number;
    stoppedAt?: number;
    completedAt?: number;
} | null): void;
export declare function syncActiveSessionSnapshot(runtime: SdkRuntime): void;
export declare function markDiagnosticTiming(runtime: SdkRuntime, mark: keyof DictumSdkDiagnostics['marks'], at?: number): void;
export declare function updateRecorderDiagnostics(runtime: SdkRuntime, patch: Partial<DictumSdkDiagnostics['recorder']>): void;
export declare function updateTransportDiagnostics(runtime: SdkRuntime, patch: Partial<DictumSdkDiagnostics['transport']>): void;
export declare function updateDebugDiagnostics(runtime: SdkRuntime, patch: Partial<DictumSdkDiagnostics['debug']>): void;
export declare function syncPermissionDiagnostics(runtime: SdkRuntime): void;
export declare function snapshotDiagnostics(runtime: SdkRuntime): DictumSdkDiagnostics;
## core/error-policy.d.ts

import type { DictumSttError, DictumSttErrorCode } from '../shared/index.js';
export type DictumErrorPhase = 'config' | 'session' | 'transcribe' | 'microphone' | 'runtime';
export type DictumDedicatedErrorEvent = 'mic_denied' | 'no_transcript' | 'network_error' | 'audio_invalid' | 'compat_failed' | 'quota_exceeded' | 'auth_required' | 'identity_expired' | 'auth_invalid';
type DictumErrorAction = NonNullable<DictumSttError['action']>;
export type DictumPublicErrorPolicyEntry = Readonly<{
    retryable: boolean;
    action: DictumErrorAction | null;
    userActionRequired: boolean;
    dedicatedEvent: DictumDedicatedErrorEvent | null;
    message: string;
}>;
export declare const PUBLIC_ERROR_POLICY: Readonly<Record<DictumSttErrorCode, DictumPublicErrorPolicyEntry>>;
/**
 * Keeps the backend operation that produced an error without adding a field to
 * the error object. This context is deliberately private: it is used only when
 * projecting an internal failure to the stable public error contract.
 */
export declare function markSdkErrorPhase<T>(error: T, phase: DictumErrorPhase): T;
export declare function resolvePublicErrorCode(params: {
    code?: unknown;
    status?: unknown;
    phase: DictumErrorPhase;
    fallbackCode?: DictumSttErrorCode;
}): DictumSttErrorCode;
export declare function createPublicError(code: DictumSttErrorCode, details?: unknown): DictumSttError;
export declare function normalizeSdkError(error: unknown, options?: {
    phase?: DictumErrorPhase;
    fallbackCode?: DictumSttErrorCode;
}): DictumSttError;
export declare function dedicatedErrorEventFor(code: DictumSttErrorCode): DictumDedicatedErrorEvent | null;
export {};
## core/insertion-target-metadata.d.ts

import type { DictumInsertionTargetSnapshot, DictumSessionTargetType } from './types.js';
export declare function readInsertionTargetId(target: DictumInsertionTargetSnapshot): string | null;
export declare function readInsertionTargetType(target: DictumInsertionTargetSnapshot): DictumSessionTargetType;
## core/microphone-permission.d.ts

import type { SdkRuntime } from './types.js';
export type DictumMicrophoneErrorCode = 'microphone_permission_denied' | 'microphone_not_found' | 'microphone_busy' | 'microphone_unsupported' | 'microphone_security_blocked' | 'microphone_capture_failed';
export declare class DictumMicrophonePermissionError extends Error {
    code: DictumMicrophoneErrorCode;
    details: unknown;
    raw: unknown;
    constructor(message: string, options: {
        code: DictumMicrophoneErrorCode;
        details?: unknown;
        raw?: unknown;
    });
}
export declare function requestMicrophoneStream(runtime: SdkRuntime): Promise<MediaStream>;
## core/network.d.ts

export declare class DictumNetworkTimeoutError extends Error {
    code: string;
    details: unknown;
    constructor(message: string, details: unknown);
}
export declare class DictumNetworkError extends Error {
    code: string;
    details: unknown;
    constructor(message: string, details: unknown);
}
export declare class DictumNetworkStreamError extends Error {
    code: string;
    details: unknown;
    constructor(message: string, details: unknown);
}
export declare class DictumResponseLimitError extends Error {
    code: string;
    details: unknown;
    constructor(message: string, details: unknown);
}
export declare const CONTROL_RESPONSE_MAX_BYTES: number;
export declare const SSE_EVENT_BUFFER_MAX_CHARS: number;
export declare const TRANSCRIPT_MAX_CHARS = 4000000;
export declare const WEBSOCKET_FRAME_MAX_CHARS: number;
export declare function fetchWithInactivityTimeout(url: string, options: RequestInit & {
    credentials: 'omit';
}, params: {
    timeoutMs?: number;
    label: string;
    streamResponse?: boolean;
    maxResponseBytes?: number;
}): Promise<Response>;
type StreamInterruptionCode = 'NETWORK_ERROR' | 'stream_lost';
export declare function readResponseTextWithLimit(response: Response, maxBytes: number, label: string, options?: {
    timeoutMs?: number;
    signal?: AbortSignal;
    interruptionCode?: StreamInterruptionCode;
}): Promise<string>;
export declare function readSseStreamChunkWithInactivityTimeout(reader: ReadableStreamDefaultReader<Uint8Array>, timeoutMs: number, rid: string, signal?: AbortSignal): Promise<ReadableStreamReadResult<Uint8Array>>;
export {};
## core/page-session-coordinator.d.ts

export type DictumPageSessionOwner = Readonly<{
    destroy(): Promise<void>;
}>;
export declare function reservePageSession(params: {
    owner: DictumPageSessionOwner;
    assertAvailable(): void;
    onPreviousCleanupError(error: unknown): void;
}): Promise<void>;
export declare function releasePageSession(owner: DictumPageSessionOwner): void;
## core/platform-events.d.ts

import type { DictumPlatformDiagnosticsEvent, DictumPlatformPublicEventOf, SdkRuntime, STTEventType } from './types.js';
export declare function emitPlatformEvent<T extends STTEventType>(runtime: SdkRuntime, event: DictumPlatformPublicEventOf<T>, domTarget?: Element | null): void;
export declare function emitPlatformEvent(runtime: SdkRuntime, event: DictumPlatformDiagnosticsEvent, domTarget?: Element | null): void;
## core/public-config-error.d.ts

export type DictumSdkConfigErrorReason = 'invalid_type' | 'invalid_value' | 'missing_value' | 'out_of_range' | 'unknown_key';
export declare class DictumSdkConfigError extends Error {
    readonly path: string;
    readonly reason: DictumSdkConfigErrorReason;
    readonly code = "invalid_config";
    constructor(path: string, reason: DictumSdkConfigErrorReason, message: string);
    toJSON(): Readonly<{
        name: 'DictumSdkConfigError';
        code: 'invalid_config';
        path: string;
        reason: DictumSdkConfigErrorReason;
        message: string;
    }>;
}
## core/public-config.d.ts

import type { DictumAudioCaptureAdapter, DictumCustomInsertionAdapter, DictumPlatformEventAdapter, STTInsertMode } from './types.js';
export declare const DEFAULT_DICTUM_API_BASE_URL = "https://dictum-sdk-api.agentcore.workers.dev";
export type NormalizedSdkTarget = HTMLElement | DictumCustomInsertionAdapter;
export type NormalizedSdkSessionConfig = Readonly<{
    projectKey: string;
    identityToken: string | null;
    target: NormalizedSdkTarget;
    apiBaseUrl: string;
    debug: boolean;
    domEvents: boolean;
    insertMode: STTInsertMode | undefined;
    volumeMeter: boolean | Readonly<{
        intervalMs?: number;
    }>;
    audioCapture: DictumAudioCaptureAdapter | undefined;
    platformEvents: DictumPlatformEventAdapter | undefined;
}>;
export declare function normalizeVolumeMeterIntervalMs(intervalMs: unknown): number;
/** Validates and snapshots the complete public configuration before any preload or session work. */
export declare function normalizeSdkSessionConfig(value: unknown): NormalizedSdkSessionConfig;
export declare function normalizeSdkCompatibilityOptions(value: unknown): Readonly<{
    audioCapture: DictumAudioCaptureAdapter | undefined;
}>;
## core/public-events.d.ts

import type { DictumSessionTargetContext, STTError, STTEventDataMap, STTEventOf, STTEventType, STTState, SdkRuntime } from './types.js';
/**
 * Emits the public STT event contract.
 *
 * This is the single bridge from internal sdk/transport activity to the
 * stable public API: session listeners and platform event adapters all receive
 * the same normalized payload. The default web adapter also mirrors public
 * events as DOM CustomEvents.
 */
export declare function emitSttEvent<T extends STTEventType>(runtime: SdkRuntime, target: DictumSessionTargetContext, params: {
    type: T;
    sessionId: string;
    state: STTEventOf<T>['state'];
    data: STTEventDataMap[T];
}): STTEventOf<T>;
export declare function emitSdkErrorEvents(runtime: SdkRuntime, target: DictumSessionTargetContext, params: {
    sessionId: string;
    state: STTState;
    error: STTError;
}): void;
## core/types.d.ts

import type { DictumSttError, DictumSttEvent, DictumSttEventDataMap, DictumSttEventOf, DictumSttEventType, DictumSttInsertMode, DictumSttResult, DictumSttState, DictumSttTransport, DictumSttVolume, SdkConfigResponse } from '../shared/index.js';
export type DictumSdkState = DictumSttState;
export type DictumSessionPhase = 'starting' | 'recording' | 'stopping' | 'uploading' | 'waiting' | 'complete';
export type DictumMicrophonePermissionState = 'unknown' | 'prompt' | 'granted' | 'denied' | 'unsupported';
export type DictumDiagnosticLevel = 'info' | 'warn' | 'error';
export type DictumDiagnosticCode = 'SDK_BOOTED' | 'CONFIG_LOAD_FAILED' | 'FIELD_CONFIG_INVALID' | 'SESSION_CREATED' | 'SESSION_STALE' | 'RECORDER_STARTING' | 'RECORDER_RECORDING' | 'RECORDER_STOPPING' | 'RECORDER_ABORTED' | 'AUDIO_TOO_LARGE' | 'AUDIO_TOO_LONG' | 'AUDIO_BUFFER_TOO_LARGE' | 'VOLUME_METER_FAILED' | 'MIC_PERMISSION_CHECK' | 'MIC_PERMISSION_GRANTED' | 'MIC_PERMISSION_DENIED' | 'MIC_SECURITY_BLOCKED' | 'MIC_NOT_FOUND' | 'MIC_BUSY' | 'MIC_UNSUPPORTED' | 'MIC_CAPTURE_FAILED' | 'WS_OPENING' | 'WS_READY' | 'WS_UNAVAILABLE' | 'WS_ABANDONED_FOR_PAUSE' | 'WS_FAILED_BEFORE_FINALIZE' | 'WS_CHUNK_SEND_FAILED' | 'WS_FINALIZE_SENT' | 'WS_TRANSCRIPT_DONE' | 'WS_FINALIZE_FAILED' | 'TRANSPORT_PENDING' | 'TRANSPORT_READY' | 'TRANSPORT_SETUP_FAILED' | 'SSE_UPLOADING' | 'SSE_COMPLETE' | 'SSE_FAILED' | 'IDENTITY_TOKEN_MISSING' | 'TARGET_UNSUPPORTED' | 'TARGET_UNAVAILABLE' | 'TRANSCRIPT_EMPTY' | 'TRANSCRIPT_INSERTED' | 'TRANSCRIPT_INSERT_FAILED' | 'UNKNOWN_ERROR';
export type DictumDiagnosticError = {
    code: DictumDiagnosticCode;
    message: string;
    at: number;
    sessionId?: string;
    status?: number;
    rid?: string;
    exact_message?: string;
    details?: unknown;
    raw?: unknown;
};
export type DictumRecorderController = {
    pause: () => Promise<void>;
    resume: () => Promise<void>;
    retry: () => Promise<string>;
    stop: () => Promise<string>;
    abort: () => Promise<void>;
};
export type DictumAudioCaptureAdapterContext = {
    readonly contentType: 'audio/wav';
    readonly sampleRateHz: 16000;
    readonly chunkMs: 100;
    readonly signal: AbortSignal;
    readonly onChunk: (chunk: Blob) => void;
};
export type DictumAudioCaptureHandle = {
    readonly startedAtMs?: number;
    readonly stop: () => void | Promise<void>;
};
export type DictumAudioCaptureAdapter = {
    readonly kind: 'audio-capture';
    readonly contentType: 'audio/wav';
    readonly start: (context: DictumAudioCaptureAdapterContext) => DictumAudioCaptureHandle | Promise<DictumAudioCaptureHandle>;
};
export type DictumPlatformPublicEventOf<T extends DictumSttEventType> = Readonly<{
    kind: 'public';
    name: `dictum:${T}`;
    targetId: string | null;
    detail: Omit<DictumSttEventOf<T>, 'sessionId'>;
}>;
export type DictumPlatformPublicEvent = {
    [T in DictumSttEventType]: DictumPlatformPublicEventOf<T>;
}[DictumSttEventType];
export type DictumPlatformDiagnosticsEvent = Readonly<{
    kind: 'diagnostics';
    name: 'dictum:diagnostics';
    detail: unknown;
}>;
export type DictumPlatformEventPayload = DictumPlatformPublicEvent | DictumPlatformDiagnosticsEvent;
export type DictumPlatformEventAdapter = {
    readonly kind: 'platform-events';
    readonly emit: (event: DictumPlatformEventPayload) => void | Promise<void>;
};
export type STTState = DictumSttState;
export type STTTransport = DictumSttTransport;
export type STTInsertMode = DictumSttInsertMode;
export type STTEventType = DictumSttEventType;
export type STTEvent = DictumSttEvent;
export type STTEventDataMap = DictumSttEventDataMap;
export type STTEventOf<T extends STTEventType> = DictumSttEventOf<T>;
export type STTResult = DictumSttResult;
export type STTError = DictumSttError;
export type STTVolume = DictumSttVolume;
export type STTStartOptions = {
    insertMode?: STTInsertMode;
};
export type DictumSessionSink = {
    readonly id: string;
    readonly state: STTState;
    setState(state: STTState): void;
    emit(event: STTEvent): void;
    complete(result: STTResult): void;
    fail(error: STTError): void;
    retainForRetry(): void;
};
export type DictumNativeInsertionTarget = {
    kind: 'native';
    element: HTMLInputElement | HTMLTextAreaElement;
    selectionStart: number;
    selectionEnd: number;
};
export type DictumContentEditableInsertionTarget = {
    kind: 'contenteditable';
    element: HTMLElement;
    range: Range | null;
};
export type DictumCustomInsertionAdapterContext = {
    readonly mode: STTInsertMode;
};
export type DictumCustomInsertionAdapter = {
    readonly kind: 'custom';
    readonly targetId?: string | null;
    readonly targetType?: string;
    readonly insertText: (text: string, context: DictumCustomInsertionAdapterContext) => void | Promise<void>;
};
export type DictumCustomInsertionTarget = {
    kind: 'custom';
    adapter: DictumCustomInsertionAdapter;
};
export type DictumInsertionTargetSnapshot = DictumNativeInsertionTarget | DictumContentEditableInsertionTarget | DictumCustomInsertionTarget;
export type DictumSessionTargetType = 'input' | 'textarea' | 'contenteditable' | 'custom';
/** Stable target metadata used by the session engine without requiring a DOM element. */
export type DictumSessionTargetContext = {
    readonly element: Element | null;
    readonly targetId: string | null;
    readonly targetType: string;
};
export type DictumDiagnosticEvent = {
    at: number;
    scope: 'sdk' | 'session' | 'recorder' | 'transport' | 'permission' | 'debug';
    level?: DictumDiagnosticLevel;
    code?: DictumDiagnosticCode;
    message: string;
    sessionId?: string;
    details?: unknown;
};
export type DictumSdkDiagnostics = {
    bootedAt: number;
    projectKeyHash: string;
    session: {
        id: string;
        state: DictumSdkState;
        phase: DictumSessionPhase;
        fieldType: string;
        createdAt?: number;
        recordingStartedAt?: number;
        stoppedAt?: number;
        completedAt?: number;
    } | null;
    activeSessionSnapshot: {
        id: string;
        state: DictumSdkState;
        phase: DictumSessionPhase;
        transport: STTTransport;
        insertMode: STTInsertMode;
        targetAttached: boolean;
        recorderAttached: boolean;
        finishRequested: boolean;
        startedAt: string;
    } | null;
    recorder: {
        state: 'ready' | 'starting' | 'recording' | 'paused' | 'stopping' | 'stopped' | 'aborted' | 'error';
        mimeType?: string;
        chunkCount: number;
        byteCount: number;
        bufferedForSse: boolean;
    };
    transport: {
        mode: 'none' | 'websocket' | 'sse_upload';
        websocketReady: boolean;
        sseUploadEnabled: boolean;
        lastProgressEvent: string | null;
        lastError: unknown;
    };
    lastError: DictumDiagnosticError | null;
    marks: {
        sessionStartedAt?: number;
        permissionGrantedAt?: number;
        websocketReadyAt?: number;
        recordingStartedAt?: number;
        stopRequestedAt?: number;
        transcriptDoneAt?: number;
        completedAt?: number;
    };
    timings: {
        clickToPermissionMs?: number;
        clickToWebSocketReadyMs?: number;
        recordingDurationMs?: number;
        stopToTranscriptMs?: number;
        totalSessionMs?: number;
    };
    permission: {
        state: DictumMicrophonePermissionState;
        checkedAt: number;
    };
    debug: {
        eventCount: number;
        lastImportant: string | null;
    };
    events: DictumDiagnosticEvent[];
};
export type DictumActiveSession = {
    id: string;
    readonly state: DictumSdkState;
    phase: DictumSessionPhase;
    target: DictumSessionTargetContext;
    insertionTarget: DictumInsertionTargetSnapshot;
    recorder: DictumRecorderController | null;
    finishRequested: boolean;
    startedAt: string;
    transport: STTTransport;
    insertMode: STTInsertMode;
    lastError: STTError | null;
};
export type SdkRuntime = {
    projectKey: string;
    identityToken: string;
    apiBaseUrl: string;
    requestSignal: AbortSignal | null;
    globalDebug: boolean;
    domEventsEnabled: boolean;
    config: SdkConfigResponse | null;
    audioCaptureAdapter: DictumAudioCaptureAdapter | null;
    platformEventAdapter: DictumPlatformEventAdapter | null;
    session: DictumSessionSink;
    publicEventSeq: number;
    activeSession: DictumActiveSession | null;
    cleanupRecorder: DictumRecorderController | null;
    microphonePermission: {
        state: DictumMicrophonePermissionState;
        checkedAt: number;
    };
    diagnostics: DictumSdkDiagnostics;
    destroyed: boolean;
};
## index.d.ts

export { checkCompatibility, createClient, DictumSdkCleanupError, DictumSdkCommandError, DictumSdkConfigError, } from './sdk.js';
export type { DictumSdkCommand, DictumSdkCommandErrorReason, DictumSdkConfigErrorReason, DictumSdkCompatibilityOptions, DictumSdkCompatibilityReport, DictumSdkEventHandler, DictumSdkEvent, DictumSdkEventName, DictumSdkErrorAction, DictumSdkAudioCaptureAdapter, DictumSdkInsertionAdapter, DictumSdkPlatformEventAdapter, DictumSdkPlatformEvent, DictumSdkClient, DictumSdkClientConfig, DictumSdkResult, DictumSdkTarget, DictumSdkTransport, } from './sdk.js';
export type { DictumBrowserCapability, DictumCompatibilityDetails, DictumSttError as DictumSdkError, DictumSttErrorCode as DictumSdkErrorCode, DictumSttEventDataMap as DictumSdkEventDataMap, DictumSttInsertMode as DictumSdkInsertMode, DictumSttState as DictumSdkState, DictumSttCompatibilityError as DictumSdkCompatibilityError, } from './shared/index.js';
## recorder/pcm16-resampler.d.ts

/**
 * Stateful, band-limited browser-audio resampler used by the AudioWorklet.
 *
 * The implementation keeps absolute input/output positions so render-quantum
 * boundaries cannot reset phase. A compact polyphase Blackman-windowed sinc
 * table avoids trigonometry in the real-time sampling loop.
 */
export type Pcm16StreamingResampler = Readonly<{
    push(samples: Float32Array): Float32Array;
    flush(): Float32Array;
    bufferedInputSamples(): number;
}>;
export declare function createPcm16StreamingResampler(sourceRateHz: number, targetRateHz?: number): Pcm16StreamingResampler;
/** Builds the self-contained Blob module loaded by AudioWorklet. */
export declare function createPcm16CaptureWorkletSource(processorName: string): string;
## recorder/post.d.ts

import type { DictumSttLimitData } from '../shared/index.js';
export declare const SSE_INACTIVITY_TIMEOUT_MS = 15000;
export declare class DictumSseError extends Error {
    code: string | undefined;
    status: number | undefined;
    rid: string | undefined;
    exact_message: string | undefined;
    details: unknown;
    raw: unknown;
    constructor(message: string, options?: {
        code?: string;
        status?: number;
        rid?: string;
        exact_message?: string;
        details?: unknown;
        raw?: unknown;
    });
}
export declare function readSseChunkWithInactivityTimeout(reader: ReadableStreamDefaultReader<Uint8Array>, timeoutMs: number, rid: string, signal?: AbortSignal): Promise<ReadableStreamReadResult<Uint8Array>>;
export declare function transcribeWithSse(params: {
    apiBaseUrl: string;
    identityToken: string;
    projectKey: string;
    audio: Blob;
    onDelta?: (text: string) => void;
    onLimit?: (limit: DictumSttLimitData) => void;
    signal?: AbortSignal;
}): Promise<string>;
## recorder/recorder-capture.d.ts

import type { SdkRuntime } from '../core/types.js';
export type RecorderAudioCapture = {
    startedAtMs: number;
    stream: MediaStream | null;
    stop: () => Promise<void>;
};
export declare function startRecorderAudioCapture(params: {
    runtime: SdkRuntime;
    sessionId: string;
    contentType: string;
    onChunk: (chunk: Blob) => void;
}): Promise<RecorderAudioCapture>;
## recorder/recorder-config.d.ts

import type { SdkRuntime } from '../core/types.js';
import type { RecorderWavCaptureMode } from './recorder-wav-capture.js';
export declare const WEBSOCKET_READY_TIMEOUT_MS = 2500;
export declare const WEBSOCKET_INACTIVITY_TIMEOUT_MS = 15000;
export declare const WEBSOCKET_AUDIO_ACK_TIMEOUT_MS = 15000;
export declare const PRE_WEBSOCKET_READY_QUEUE_TIMEOUT_MS = 15000;
export declare const PRE_WEBSOCKET_READY_QUEUE_MAX_BYTES: number;
export declare const PROCESSING_PROGRESS: {
    readonly starting: 3;
    readonly recording: 8;
    readonly stopping: 12;
    readonly uploading: 80;
    readonly waiting: 92;
    readonly complete: 100;
};
export declare function activeRecorderCaptureMode(_runtime: SdkRuntime): RecorderWavCaptureMode;
export declare function shouldUseStreaming(_runtime: SdkRuntime): boolean;
export declare function shouldUseSseUpload(_runtime: SdkRuntime): boolean;
## recorder/recorder-errors.d.ts

import type { DictumDiagnosticCode } from '../core/types.js';
export declare function debugError(error: unknown, code?: DictumDiagnosticCode): {
    code: DictumDiagnosticCode;
    status?: number;
    rid?: string;
    exact_message: string;
    details?: unknown;
    raw?: unknown;
};
## recorder/recorder-events.d.ts

import type { DictumDiagnosticCode, DictumSessionPhase, DictumSessionTargetContext, STTVolume, SdkRuntime } from '../core/types.js';
export type DictumRecorderDebugDetail = {
    message: string;
    transient?: boolean;
    status?: number;
    rid?: string;
    exact_message?: string;
    details?: unknown;
    raw?: unknown;
    sessionId?: string;
    important?: boolean;
    code?: DictumDiagnosticCode;
};
export type DictumRecorderInternalEvent = {
    type: 'debug';
    detail: DictumRecorderDebugDetail;
} | {
    type: 'phase';
    sessionId: string;
    phase: DictumSessionPhase;
    progress: number;
    label: string;
};
/**
 * Typed recorder-only signal channel.
 *
 * These signals update internal diagnostics and, in debug mode only, the
 * browser console. They deliberately never create DOM events or public SDK
 * events. Public output continues to flow exclusively through emitSttEvent().
 */
export declare function recordRecorderInternalEvent(runtime: SdkRuntime, event: DictumRecorderInternalEvent): void;
export declare function recordRecorderDebug(runtime: SdkRuntime, detail: DictumRecorderDebugDetail): void;
export declare function emitVolumeChange(runtime: SdkRuntime, target: DictumSessionTargetContext, sessionId: string, volume: number | Partial<STTVolume>): void;
export declare function recordRecorderPhase(runtime: SdkRuntime, sessionId: string, phase: DictumSessionPhase, progress: number, label: string): void;
export declare function startAudioLevelMeter(runtime: SdkRuntime, target: DictumSessionTargetContext, stream: MediaStream, sessionId: string, intervalMs?: number, onSamplingFailure?: () => void): (() => void) | null;
## recorder/recorder-limits.d.ts

import type { DictumDiagnosticCode, SdkRuntime } from '../core/types.js';
export declare function failAudioBufferLimit(params: {
    runtime: SdkRuntime;
    sessionId: string;
    code: DictumDiagnosticCode;
    message: string;
    exactMessage: string;
    details: Record<string, unknown>;
    byteCount: number;
    clearAudio: () => void;
    stopRecorder: () => Promise<void>;
}): Error;
## recorder/recorder-post.d.ts

import type { DictumSessionTargetContext, SdkRuntime } from '../core/types.js';
import type { DictumSttLimitData } from '../shared/index.js';
export declare function readPostRecoveryDelta(params: {
    publishedWebSocketPrefix: string;
    streamedPostTranscript: string;
    finalPostTranscript: string;
}): string | null;
export declare function transcribeSseUpload(params: {
    runtime: SdkRuntime;
    target: DictumSessionTargetContext;
    sessionId: string;
    audio: Blob;
    publishedWebSocketPrefix?: string;
    onLimit: (limit: DictumSttLimitData) => void;
}): Promise<string>;
## recorder/recorder-wav-capture.d.ts

export type RecorderWavCaptureMode = 'pcm16';
export declare const RECORDER_WAV_CONTENT_TYPE = "audio/wav";
export declare const RECORDER_WAV_SAMPLE_RATE = 16000;
export declare const RECORDER_WAV_CHUNK_MS = 100;
export type RecorderWavCapture = {
    stop: () => Promise<void>;
};
export declare function supportsRecorderWavCapture(): boolean;
export declare function startRecorderWavCapture(stream: MediaStream, onChunk: (chunk: Blob) => void): Promise<RecorderWavCapture>;
## recorder/recorder-websocket.d.ts

import type { DictumSessionTargetContext, SdkRuntime } from '../core/types.js';
import type { DictumSttLimitData } from '../shared/index.js';
export declare class WebSocketRecorderTransport {
    private readonly runtime;
    private readonly target;
    private readonly sessionId;
    private readonly config;
    private streaming;
    private streamingStartFailed;
    private streamingSendFailed;
    private streamingReady;
    private preReadyQueuedBytes;
    private preReadyStartedAt;
    private flushTail;
    private chunks;
    private finalizing;
    private finalized;
    private finalizePromise;
    private abandoned;
    private serverLimitReached;
    constructor(runtime: SdkRuntime, target: DictumSessionTargetContext, sessionId: string, config: {
        streamingEnabled: boolean;
        sseUploadEnabled: boolean;
        contentType: string;
        fieldType: string;
        onPublishedDelta: (text: string) => void;
        onLimit: (limit: DictumSttLimitData) => void;
        onFailure: (error: unknown) => void;
    });
    get failedBeforeFinalize(): boolean;
    get canFinalize(): boolean;
    start(): Promise<void>;
    enqueue(chunk: Blob): void;
    finalize(): Promise<string>;
    close(): void;
    private shutdownTransport;
    abandonForPause(): void;
    private disable;
    private observeTransportMessage;
    private onState;
    private onDelta;
    private onFinal;
    private onLimit;
    private markReady;
    private markStartFailed;
    private trackPreReadyQueue;
    private flush;
}
## recorder/recorder.d.ts

import type { DictumDiagnosticCode, DictumRecorderController, DictumSessionTargetContext, SdkRuntime } from '../core/types.js';
type DictumRecorderStartupController = DictumRecorderController & {
    activateTransport: () => void;
};
type DictumRecorderSessionPort = Readonly<{
    fail: (params: {
        error: unknown;
        code: DictumDiagnosticCode;
    }) => void;
    finish: () => Promise<void>;
}>;
export declare function createRecorder(_runtime: SdkRuntime, _target: DictumSessionTargetContext, _sessionId: string, options: {
    enableAudioLevelMeter?: boolean;
    audioLevelMeterIntervalMs?: number;
    sessionPort: DictumRecorderSessionPort;
}): {
    start: () => Promise<DictumRecorderStartupController>;
};
export {};
## recorder/streaming.d.ts

import { type DictumSttLimitData } from '../shared/index.js';
export type DictumStreamingProductState = 'recording' | 'transcribing';
export type DictumStreamingSession = {
    ready: Promise<void>;
    sendChunk: (chunk: Blob) => Promise<void>;
    finalize: () => Promise<string>;
    close: () => void;
};
export declare class DictumTransportError extends Error {
    code: string | undefined;
    status: number | undefined;
    rid: string | undefined;
    exact_message: string | undefined;
    details: unknown;
    raw: unknown;
    constructor(message: string, options?: {
        code?: string;
        status?: number;
        rid?: string;
        exact_message?: string;
        details?: unknown;
        raw?: unknown;
    });
}
export declare function openStreamingSession(params: {
    apiBaseUrl: string;
    identityToken: string;
    projectKey: string;
    contentType: string;
    fieldType: string;
    inactivityTimeoutMs: number;
    audioAckTimeoutMs: number;
    onState?: (state: DictumStreamingProductState) => void;
    onDelta?: (text: string) => void;
    onFinal?: (text: string) => void;
    onLimit?: (limit: DictumSttLimitData) => void;
    onFailure?: (error: DictumTransportError) => void;
}): DictumStreamingSession;
## recorder/transport-adapters.d.ts

import type { DictumSttLimitData } from '../shared/index.js';
import { type DictumStreamingProductState } from './streaming.js';
export type RawTransportMessage = {
    transport: 'sse';
    kind: 'started';
    payload: {
        sessionId: string;
    };
} | {
    transport: 'sse';
    kind: 'delta';
    payload: {
        text: string;
    };
} | {
    transport: 'sse';
    kind: 'limit';
    payload: DictumSttLimitData;
} | {
    transport: 'sse';
    kind: 'transcript.final';
    payload: {
        text: string;
    };
} | {
    transport: 'websocket';
    kind: 'started';
    payload: {
        sessionId: string;
    };
} | {
    transport: 'websocket';
    kind: 'state';
    payload: {
        state: DictumStreamingProductState;
    };
} | {
    transport: 'websocket';
    kind: 'limit';
    payload: DictumSttLimitData;
} | {
    transport: 'websocket';
    kind: 'transcript.delta';
    payload: {
        text: string;
    };
} | {
    transport: 'websocket';
    kind: 'transcript.final';
    payload: {
        text: string;
    };
} | {
    transport: 'websocket';
    kind: 'done';
    payload: {
        text: string;
    };
};
export type SseTransportContext = {
    sessionId: string;
    apiBaseUrl: string;
    identityToken: string;
    projectKey: string;
    audio: Blob;
    signal?: AbortSignal;
    onLimit?: (limit: DictumSttLimitData) => void;
};
export type WebSocketTransportContext = {
    sessionId: string;
    apiBaseUrl: string;
    identityToken: string;
    projectKey: string;
    contentType: string;
    fieldType: string;
    inactivityTimeoutMs: number;
    audioAckTimeoutMs: number;
    onState?: (state: DictumStreamingProductState) => void;
    onDelta?: (text: string) => void;
    onFinal?: (text: string) => void;
    onLimit?: (limit: DictumSttLimitData) => void;
};
export declare class SseTransportAdapter {
    private readonly messageCallbacks;
    private readonly errorCallbacks;
    onMessage(callback: (message: RawTransportMessage) => void): () => void;
    onError(callback: (error: unknown) => void): () => void;
    transcribe(context: SseTransportContext): Promise<string>;
    private emitMessage;
    private emitError;
}
export declare class WebSocketTransportAdapter {
    private readonly messageCallbacks;
    private readonly errorCallbacks;
    private streaming;
    ready: Promise<void>;
    onMessage(callback: (message: RawTransportMessage) => void): () => void;
    onError(callback: (error: unknown) => void): () => void;
    start(context: WebSocketTransportContext): void;
    sendChunk(chunk: Blob): Promise<void>;
    finalize(): Promise<string>;
    close(): void;
    private emitMessage;
    private emitError;
}
## recorder/wav.d.ts

export declare const WAV_CONTENT_TYPE = "audio/wav";
export declare const WAV_SAMPLE_RATE = 16000;
export declare const WAV_CHANNELS = 1;
export declare const WAV_BITS_PER_SAMPLE = 16;
export declare function createWavBlobFromPcm16(pcm: ArrayBuffer): Blob;
export declare function createSessionWavBlobFromChunks(chunks: Blob[]): Promise<Blob>;
export declare function measureWavPcm16Volume(buffer: ArrayBuffer): {
    level: number;
    rms: number;
    peak: number;
};
export declare function extractPcm16MonoFromWav(buffer: ArrayBuffer): ArrayBuffer;
## sdk.d.ts

import type { DictumAudioCaptureAdapter, DictumCustomInsertionAdapter, DictumPlatformEventAdapter, DictumPlatformEventPayload, STTEvent, STTEventOf, STTEventType, STTInsertMode, STTResult, STTState, STTTransport } from './core/types.js';
import type { DictumBrowserCapability, DictumSttErrorAction } from './shared/index.js';
export type DictumSdkTarget = HTMLElement | DictumCustomInsertionAdapter;
export type DictumSdkInsertionAdapter = DictumCustomInsertionAdapter;
export type DictumSdkAudioCaptureAdapter = DictumAudioCaptureAdapter;
export type DictumSdkPlatformEventAdapter = DictumPlatformEventAdapter;
export type DictumSdkPlatformEvent = DictumPlatformEventPayload;
export type DictumSdkTransport = STTTransport;
export type DictumSdkErrorAction = DictumSttErrorAction;
export type DictumSdkCompatibilityOptions = {
    readonly audioCapture?: DictumSdkAudioCaptureAdapter;
};
export type DictumSdkCompatibilityReport = Readonly<{
    supported: boolean;
    capture: 'sdk' | 'custom';
    missing: readonly DictumBrowserCapability[];
}>;
export { DictumSdkCommandError } from './session/session-command-error.js';
export { DictumSdkCleanupError } from './session/session-cleanup-error.js';
export { DictumSdkConfigError } from './core/public-config-error.js';
export type { DictumSdkCommand, DictumSdkCommandErrorReason } from './session/session-command-error.js';
export type { DictumSdkConfigErrorReason } from './core/public-config-error.js';
export type DictumSdkClientConfig = {
    readonly projectKey: string;
    readonly identityToken?: string | null;
    readonly target: DictumSdkTarget;
    readonly apiBaseUrl?: string;
    readonly debug?: boolean;
    readonly domEvents?: boolean;
    readonly insertMode?: STTInsertMode;
    readonly volumeMeter?: boolean | {
        readonly intervalMs?: number;
    };
    readonly audioCapture?: DictumSdkAudioCaptureAdapter;
    readonly platformEvents?: DictumSdkPlatformEventAdapter;
};
export type DictumSdkEventName = STTEvent['type'] | '*';
export type DictumSdkEvent<T extends STTEventType = STTEventType> = Omit<STTEventOf<T>, 'sessionId'>;
export type DictumSdkEventHandler<T extends DictumSdkEventName = DictumSdkEventName> = (event: T extends STTEventType ? DictumSdkEvent<T> : Omit<STTEvent, 'sessionId'>) => void | Promise<void>;
export type DictumSdkResult = Omit<STTResult, 'sessionId'>;
/** Non-mutating capability report for hosts that want to disable their voice UI before creating a session. */
export declare function checkCompatibility(options?: DictumSdkCompatibilityOptions): DictumSdkCompatibilityReport;
export type DictumSdkClient = {
    readonly target: DictumSdkTarget;
    readonly state: STTState;
    start(): Promise<void>;
    pause(): Promise<void>;
    resume(): Promise<void>;
    stop(): Promise<DictumSdkResult>;
    retry(): Promise<void>;
    waitForResult(): Promise<DictumSdkResult>;
    destroy(): Promise<void>;
    on<T extends DictumSdkEventName>(eventName: T, handler: DictumSdkEventHandler<T>): () => void;
    off<T extends DictumSdkEventName>(eventName: T, handler: DictumSdkEventHandler<T>): void;
};
export declare function createClient(config: DictumSdkClientConfig): DictumSdkClient;
## session/insert-text.d.ts

import type { DictumCustomInsertionAdapter, DictumInsertionTargetSnapshot, DictumSessionTargetContext, STTInsertMode } from '../core/types.js';
export type DictumInsertionTargetInput = Element | DictumCustomInsertionAdapter;
export declare function isCustomInsertionAdapter(target: unknown): target is DictumCustomInsertionAdapter;
export declare function createSessionTargetContext(target: DictumInsertionTargetInput): DictumSessionTargetContext;
export declare function captureInsertionTarget(field: DictumInsertionTargetInput): DictumInsertionTargetSnapshot;
export declare function insertText(target: DictumInsertionTargetSnapshot, text: string, mode?: STTInsertMode, _internalOperationId?: string): Promise<STTInsertMode>;
## session/public-session.d.ts

import { type DictumErrorPhase } from '../core/error-policy.js';
import type { STTError, STTInsertMode, STTStartOptions } from '../core/types.js';
export declare function normalizeError(error: unknown, phase?: DictumErrorPhase): STTError;
export declare function resolveInsertMode(options: STTStartOptions | undefined): STTInsertMode;
## session/session-cleanup-error.d.ts

export declare class DictumSdkCleanupError extends Error {
    readonly code = "cleanup_failed";
    constructor();
}
## session/session-command-error.d.ts

import type { STTState } from '../core/types.js';
export type DictumSdkCommand = 'start' | 'pause' | 'resume' | 'stop' | 'retry';
export type DictumSdkCommandErrorReason = 'already_started' | 'command_in_progress' | 'destroyed' | 'invalid_state' | 'not_retryable' | 'dictation_settled';
export declare class DictumSdkCommandError extends Error {
    readonly command: DictumSdkCommand;
    readonly state: STTState;
    readonly reason: DictumSdkCommandErrorReason;
    readonly code = "invalid_command";
    constructor(command: DictumSdkCommand, state: STTState, reason: DictumSdkCommandErrorReason);
}
## session/session-controller.d.ts

import type { DictumInsertionTargetSnapshot, DictumSessionTargetContext, STTStartOptions, SdkRuntime } from '../core/types.js';
export type DictumSessionPresentation = {
    enableAudioLevelMeter: boolean;
    audioLevelMeterIntervalMs?: number;
};
export declare function startSession(params: {
    runtime: SdkRuntime;
    target: DictumSessionTargetContext;
    presentation: DictumSessionPresentation;
    insertionTarget: DictumInsertionTargetSnapshot;
    options: STTStartOptions;
}): Promise<void>;
## session/session-lifecycle.d.ts

import { type DictumErrorPhase } from '../core/error-policy.js';
import type { DictumDiagnosticCode, DictumSessionTargetContext, STTError, SdkRuntime } from '../core/types.js';
export declare function readTransport(): 'websocket';
export declare function readDiagnosticFieldType(target: DictumSessionTargetContext): string;
export declare function syncActiveSessionDiagnostics(runtime: SdkRuntime): void;
export declare function clearSessionIfCurrent(runtime: SdkRuntime, sessionId: string): boolean;
export declare function failActiveSession(runtime: SdkRuntime, sessionId: string, params: {
    error: unknown;
    code?: DictumDiagnosticCode;
    phase?: DictumErrorPhase;
    diagnosticError?: unknown;
}): STTError | false;
export declare function finishSession(runtime: SdkRuntime, sessionId: string): Promise<void>;
export declare function retryActiveSession(runtime: SdkRuntime, sessionId: string): Promise<void>;
## session/state-machine.d.ts

import type { DictumSessionTargetContext, STTState, SdkRuntime } from '../core/types.js';
export type DictumSessionCommand = 'start' | 'pause' | 'resume' | 'stop' | 'transcribe' | 'retry' | 'success' | 'fail';
export declare const SESSION_TRANSITION_TABLE: {
    readonly idle: {
        readonly start: "requesting_mic";
        readonly fail: "failed";
    };
    readonly requesting_mic: {
        readonly start: "listening";
        readonly fail: "failed";
    };
    readonly listening: {
        readonly pause: "paused";
        readonly stop: "transcribing";
        readonly transcribe: "transcribing";
        readonly fail: "failed";
    };
    readonly paused: {
        readonly resume: "listening";
        readonly stop: "transcribing";
        readonly transcribe: "transcribing";
        readonly fail: "failed";
    };
    readonly retrying: {
        readonly success: "idle";
        readonly fail: "failed";
    };
    readonly transcribing: {
        readonly success: "idle";
        readonly fail: "failed";
    };
    readonly failed: {
        readonly retry: "retrying";
    };
};
export declare class InvalidSessionTransitionError extends Error {
    readonly previousState: STTState;
    readonly command: DictumSessionCommand;
    constructor(previousState: STTState, command: DictumSessionCommand);
}
export declare function nextSessionState(previousState: STTState, command: DictumSessionCommand): STTState;
export declare function dispatchSessionCommand(params: {
    runtime: SdkRuntime;
    sessionId: string;
    command: DictumSessionCommand;
    target?: DictumSessionTargetContext;
}): boolean;
## session/stt-result.d.ts

import type { DictumActiveSession, STTInsertMode, STTResult } from '../core/types.js';
/**
 * Builds the single public STTResult shape for every transport.
 */
export declare function buildSttResult(params: {
    session: DictumActiveSession;
    text: string;
    endedAt?: string;
    inserted: boolean;
    insertMode: STTInsertMode;
}): STTResult;
## shared/api-types.d.ts

export type SdkConfigResponse = {
    enabled: boolean;
};
export type SdkConfigApiResponse = {
    ok: true;
    sdk: SdkConfigResponse;
} | {
    ok: false;
    rid: string;
    error: import('./errors.js').ApiError;
};
export type CreateSDKSessionRequest = {
    project_key: string;
    identity_token: string;
};
export type CreateSDKSessionResponse = {
    expires_at: string;
    session_id: string;
};
## shared/contracts/dictum-sdk.d.ts

import { type ApiError } from '../errors.js';
export declare const DICTUM_SDK_CONTRACT: {
    readonly contract: {
        readonly route: "/api/sdk/contract";
        readonly method: "GET";
    };
    readonly config: {
        readonly route: "/api/sdk/config";
        readonly method: "GET";
        readonly projectKeyParam: "p";
        readonly purpose: "project_runtime_activation";
    };
    readonly transcribe: {
        readonly route: "/api/sdk/transcribe";
        readonly method: "POST";
    };
    readonly websocket: {
        readonly route: "/api/sdk/ws";
        readonly protocol: "dictum.v1";
        readonly ridProtocolPrefix: "dictum.rid.";
        readonly authProtocolPrefix: "dictum.auth.";
        readonly initType: "init";
        readonly finalizeType: "finalize";
        readonly stateType: "state";
        readonly ackType: "ack";
        readonly limitType: "limit";
        readonly deltaType: "delta";
        readonly finalType: "final";
        readonly doneType: "done";
        readonly events: readonly ["state", "ack", "limit", "delta", "final", "done", "error"];
    };
    readonly headers: {
        readonly authorization: "authorization";
        readonly contentType: "content-type";
        readonly requestId: "x-request-id";
        readonly projectKey: "x-dictum-project-key";
    };
};
export type DictumSdkWebSocketInitFrame = {
    type: typeof DICTUM_SDK_CONTRACT.websocket.initType;
    rid: string;
    authorization: string;
    projectKey: string;
    contentType: string;
    fieldType: string;
};
export type DictumSdkWebSocketFinalizeFrame = {
    type: typeof DICTUM_SDK_CONTRACT.websocket.finalizeType;
};
export type DictumSdkWebSocketTranscriptFrame = {
    ok: false;
    rid: string;
    error: ApiError;
} | {
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.stateType;
    value: 'recording' | 'transcribing';
} | {
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.ackType;
    stage: 'audio';
    chunkCount: number;
    totalBytes: number;
    audioDurationMs?: number;
    audioDurationSeconds?: number;
    audioDataBytes?: number;
    audioBytes?: number;
    maxAudioDurationMs?: number;
    maxAudioDurationSeconds?: number;
    maxAudioBytes?: number;
    audioLimitReached?: boolean;
} | ({
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.limitType;
} & DictumSttLimitData) | {
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.deltaType;
    text: string;
} | {
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.finalType;
    rid: string;
    text: string;
    firstTokenMs?: number;
    lastTokenMs?: number;
} | {
    ok?: true;
    type: typeof DICTUM_SDK_CONTRACT.websocket.doneType;
    rid: string;
};
export declare const DICTUM_STT_EVENT_CONTRACT: {
    readonly publicEvents: readonly ["state_changed", "volume_changed", "transcript_delta", "text_inserted", "mic_denied", "no_transcript", "network_error", "audio_invalid", "compat_failed", "limit_reached", "fallback_started", "quota_exceeded", "auth_required", "identity_expired", "auth_invalid", "retry_started", "sdk_error"];
    readonly publicStates: readonly ["idle", "requesting_mic", "listening", "paused", "retrying", "transcribing", "failed"];
    readonly publicErrors: readonly ["microphone_permission_denied", "microphone_not_found", "browser_unsupported", "sdk_disabled", "network_error", "stream_lost", "transcription_failed", "transport_response_invalid", "empty_audio", "no_speech_detected", "quota_exceeded", "unsupported_audio_type", "audio_too_large", "rate_limited", "timeout", "aborted_by_user", "client_not_authenticated", "identity_expired", "config_response_invalid", "session_response_invalid", "auth_config_error"];
    readonly transports: readonly ["post", "websocket"];
    readonly sse: {
        readonly events: readonly ["start", "state", "delta", "done", "error"];
    };
    readonly websocket: {
        readonly events: readonly ["state", "ack", "limit", "delta", "final", "done", "error"];
    };
};
export type DictumSttEventType = typeof DICTUM_STT_EVENT_CONTRACT.publicEvents[number];
export type DictumSttState = typeof DICTUM_STT_EVENT_CONTRACT.publicStates[number];
export type DictumSttErrorCode = typeof DICTUM_STT_EVENT_CONTRACT.publicErrors[number];
export type DictumSttTransport = typeof DICTUM_STT_EVENT_CONTRACT.transports[number];
export type DictumSttInsertMode = 'replace' | 'append' | 'insert-at-cursor' | 'manual';
export type DictumSttStateChangedData = {
    readonly previousState: DictumSttState;
    readonly nextState: DictumSttState;
};
export type DictumSttTranscriptDeltaData = {
    readonly text: string;
    readonly transport: DictumSttTransport;
};
export type DictumSttTextInsertedData = {
    readonly text: string;
    readonly insertMode: Exclude<DictumSttInsertMode, 'manual'>;
};
export type DictumSttLimitData = {
    readonly reason: 'duration' | 'size';
    readonly durationMs: number;
    readonly maxSeconds: number;
    readonly bytes: number;
    readonly maxBytes: number;
    readonly action: 'transcribing';
};
export type DictumSttRetryData = {
    readonly transport: 'post';
};
export type DictumSttFallbackData = {
    readonly from: 'websocket';
    readonly to: 'post';
    readonly reason: 'setup_failed' | 'stream_lost' | 'finalize_failed' | 'paused';
};
export type DictumBrowserCapability = 'AbortController' | 'ArrayBuffer' | 'AudioContext' | 'AudioContext.audioWorklet' | 'AudioWorkletNode' | 'Blob' | 'Blob.arrayBuffer' | 'browser_page' | 'DataView' | 'Headers' | 'ReadableStream' | 'ReadableStream.getReader' | 'Response' | 'TextDecoder' | 'URL.createObjectURL' | 'URL.revokeObjectURL' | 'crypto.getRandomValues' | 'fetch' | 'secure_context' | 'navigator.mediaDevices.getUserMedia';
export type DictumCompatibilityDetails = {
    readonly missing: readonly DictumBrowserCapability[];
    readonly capture: 'sdk' | 'custom';
};
export type DictumSttErrorAction = 'grant_microphone' | 'sign_in' | 'reload_page' | 'provide_identity_token' | 'retry_network' | 'update_browser';
type DictumSttErrorShape<C extends DictumSttErrorCode, R extends boolean, A extends DictumSttErrorAction | null> = {
    readonly code: C;
    readonly message: string;
    readonly retryable: R;
    readonly userActionRequired: A extends null ? false : true;
    readonly details?: never;
} & (A extends DictumSttErrorAction ? {
    readonly action: A;
} : {
    readonly action?: never;
});
export type DictumSttCompatibilityError = {
    readonly code: 'browser_unsupported';
    readonly message: string;
    readonly retryable: false;
    readonly userActionRequired: true;
    readonly action: 'update_browser';
    readonly details: DictumCompatibilityDetails;
};
export type DictumSttErrorOf<C extends DictumSttErrorCode> = Extract<DictumSttError, {
    code: C;
}>;
export type DictumSttNoTranscriptData = Readonly<{
    reason: 'empty_audio';
    error: DictumSttErrorOf<'empty_audio'>;
}> | Readonly<{
    reason: 'no_speech';
    error: DictumSttErrorOf<'no_speech_detected'>;
}>;
export type DictumSttEventDataMap = {
    readonly state_changed: DictumSttStateChangedData;
    readonly volume_changed: DictumSttVolume;
    readonly transcript_delta: DictumSttTranscriptDeltaData;
    readonly text_inserted: DictumSttTextInsertedData;
    readonly mic_denied: DictumSttErrorOf<'microphone_permission_denied'>;
    readonly no_transcript: DictumSttNoTranscriptData;
    readonly network_error: DictumSttErrorOf<'network_error' | 'stream_lost' | 'timeout'>;
    readonly audio_invalid: DictumSttErrorOf<'unsupported_audio_type' | 'audio_too_large'>;
    readonly compat_failed: DictumSttCompatibilityError;
    readonly limit_reached: DictumSttLimitData;
    readonly fallback_started: DictumSttFallbackData;
    readonly quota_exceeded: DictumSttErrorOf<'quota_exceeded'>;
    readonly auth_required: DictumSttErrorOf<'client_not_authenticated'>;
    readonly identity_expired: DictumSttErrorOf<'identity_expired'>;
    readonly auth_invalid: DictumSttErrorOf<'auth_config_error'>;
    readonly retry_started: DictumSttRetryData;
    readonly sdk_error: DictumSttError;
};
type DictumSttEventBase<T extends DictumSttEventType> = {
    readonly type: T;
    readonly sessionId: string;
    readonly targetId?: string | null;
    readonly state: DictumSttState;
    readonly timestamp: string;
    readonly seq: number;
    readonly data: DictumSttEventDataMap[T];
};
export type DictumSttEventOf<T extends DictumSttEventType> = T extends DictumSttEventType ? DictumSttEventBase<T> : never;
export type DictumSttEvent = DictumSttEventOf<DictumSttEventType>;
export type DictumSttResult = {
    readonly sessionId: string;
    readonly text: string;
    readonly startedAt: string;
    readonly endedAt: string;
    readonly inserted: boolean;
    readonly insertMode: DictumSttInsertMode;
    readonly target: {
        readonly targetId: string | null;
        readonly type: 'input' | 'textarea' | 'contenteditable' | 'custom';
    };
    readonly transport: DictumSttTransport;
};
export type DictumSttError = DictumSttErrorShape<'microphone_permission_denied', false, 'grant_microphone'> | DictumSttErrorShape<'microphone_not_found', false, null> | DictumSttCompatibilityError | DictumSttErrorShape<'sdk_disabled', false, null> | DictumSttErrorShape<'network_error', true, 'retry_network'> | DictumSttErrorShape<'stream_lost', true, 'retry_network'> | DictumSttErrorShape<'transcription_failed', false, null> | DictumSttErrorShape<'transport_response_invalid', false, null> | DictumSttErrorShape<'empty_audio', false, null> | DictumSttErrorShape<'no_speech_detected', false, null> | DictumSttErrorShape<'quota_exceeded', false, null> | DictumSttErrorShape<'unsupported_audio_type', false, null> | DictumSttErrorShape<'audio_too_large', false, null> | DictumSttErrorShape<'rate_limited', true, 'retry_network'> | DictumSttErrorShape<'timeout', true, 'retry_network'> | DictumSttErrorShape<'aborted_by_user', false, null> | DictumSttErrorShape<'client_not_authenticated', false, 'sign_in'> | DictumSttErrorShape<'identity_expired', false, 'reload_page'> | DictumSttErrorShape<'config_response_invalid', false, null> | DictumSttErrorShape<'session_response_invalid', false, null> | DictumSttErrorShape<'auth_config_error', false, 'provide_identity_token'>;
export type DictumSttVolume = {
    readonly level: number;
    readonly rms?: number;
    readonly peak?: number;
};
export type DictumSseEvent = {
    eventName: string;
    payload: unknown;
};
export declare class DictumSdkProtocolError extends Error {
    exact_message: string;
    details: unknown;
    raw: unknown;
    constructor(message: string, options?: {
        details?: unknown;
        raw?: unknown;
    });
}
export declare function createDictumRequestId(): string;
export declare function buildDictumUrl(apiBaseUrl: string, route: string): string;
export declare function buildDictumWebSocketUrl(apiBaseUrl: string): string;
export declare function toDictumBase64Url(value: string): string;
export declare function buildDictumWebSocketProtocols(params: {
    rid: string;
    authorization: string;
}): string[];
export declare function buildDictumWebSocketInitFrame(params: Omit<DictumSdkWebSocketInitFrame, 'type'>): DictumSdkWebSocketInitFrame;
export declare function buildDictumWebSocketFinalizeFrame(): DictumSdkWebSocketFinalizeFrame;
export declare function buildDictumPublicEvent<T extends DictumSttEventType>(params: {
    type: T;
    sessionId: string;
    targetId?: string | null;
    state: DictumSttState;
    timestamp?: string;
    seq: number;
    data: DictumSttEventDataMap[T];
}): DictumSttEventOf<T>;
export declare function parseDictumSseEventBlock(block: string): DictumSseEvent | null;
export declare function parseDictumTranscriptFrame(raw: unknown): DictumSdkWebSocketTranscriptFrame;
export {};
## shared/errors.d.ts

export type LegacyApiError = {
    worker: string;
    source: 'internal' | 'external';
    status: number;
    exact_message: string;
};
export type ApiErrorCategory = 'validation' | 'authentication' | 'authorization' | 'configuration' | 'quota' | 'conflict' | 'not_found' | 'dependency' | 'internal' | 'security' | 'cancelled';
export type CatalogApiError = {
    code: string;
    message: string;
    category: ApiErrorCategory;
    retryable: boolean;
    action?: string;
    field?: string;
    docs_url?: string;
    retry_after_ms?: number;
    details?: Record<string, string | number | boolean | null>;
};
export type ApiError = LegacyApiError | CatalogApiError;
export declare class ApiHttpStatusMismatchError extends Error {
    readonly code = "HTTP_ERROR_STATUS_MISMATCH";
    readonly details: Readonly<{
        httpStatus: number;
        envelopeStatus: number;
    }>;
    constructor(httpStatus: number, envelopeStatus: number);
}
export declare function isLegacyApiError(value: unknown): value is LegacyApiError;
export declare function isCatalogApiError(value: unknown): value is CatalogApiError;
export declare function apiErrorCode(error: ApiError | null): string | undefined;
/**
 * Projects a validated Worker catalog error onto the SDK's stable internal
 * classification vocabulary when no HTTP status exists (SSE/WS frames).
 * Human-readable messages are deliberately excluded from this decision.
 */
export declare function apiErrorSdkCode(error: ApiError | null): string | undefined;
export declare function apiErrorMessage(error: ApiError | null, fallback: string): string;
/** Returns the authoritative HTTP status and rejects contradictory Legacy envelopes. */
export declare function apiErrorStatus(error: ApiError | null, httpStatus: number): number;
/** Reads the embedded Legacy status for transport frames that have no HTTP status. */
export declare function apiErrorEmbeddedStatus(error: ApiError | null, fallback: number): number;
export type ApiSuccess<T> = {
    ok: true;
    data: T;
};
export type ApiFailure = {
    ok: false;
    rid: string;
    error: ApiError;
};
export declare function isApiFailure(value: unknown): value is ApiFailure;
export type ApiResponse<T> = ApiSuccess<T> | ApiFailure;
## shared/ids.d.ts

export declare function createCryptographicId(prefix: string): string;
## shared/index.d.ts

export * from './api-types.js';
export * from './contracts/dictum-sdk.js';
export * from './errors.js';
export * from './ids.js';