med-scribe-alliance-ts-sdk 1.0.13 → 2.0.1

package/dist/index.d.ts

@@ -1,12 +1,1069 @@
+export declare enum SessionStatus {
+	CREATED = "created",
+	RECORDING = "recording",
+	INITIALIZED = "initialized",
+	PROCESSING = "processing",
+	COMPLETED = "completed",
+	PARTIAL = "partial",
+	FAILED = "failed",
+	EXPIRED = "expired"
+}
+export declare enum TemplateStatus {
+	SUCCESS = "success",
+	FAILED = "failed",
+	PROCESSING = "processing"
+}
+export declare enum UploadType {
+	CHUNKED = "chunked",
+	SINGLE = "single"
+}
+export declare enum CommunicationProtocol {
+	WEBSOCKET = "websocket",
+	HTTP = "http",
+	RPC = "rpc"
+}
+export declare enum TransportMode {
+	DIRECT = "direct",
+	IPC = "ipc"
+}
+export declare enum ErrorCode {
+	AUTHENTICATION_FAILED = "authentication_failed",
+	TOKEN_EXPIRED = "token_expired",
+	INVALID_API_KEY = "invalid_api_key",
+	FORBIDDEN = "forbidden",
+	RATE_LIMIT_EXCEEDED = "rate_limit_exceeded",
+	SESSION_NOT_FOUND = "session_not_found",
+	TEMPLATE_NOT_FOUND = "template_not_found",
+	SESSION_EXPIRED = "session_expired",
+	INVALID_REQUEST = "invalid_request",
+	INVALID_AUDIO_FORMAT = "invalid_audio_format",
+	CHUNK_TOO_LARGE = "chunk_too_large",
+	INVALID_TEMPLATE = "invalid_template",
+	MISSING_REQUIRED_FIELD = "missing_required_field",
+	PROCESSING_FAILED = "processing_failed",
+	AUDIO_QUALITY_POOR = "audio_quality_poor",
+	AUDIO_TOO_SHORT = "audio_too_short",
+	LANGUAGE_UNSUPPORTED = "language_unsupported",
+	INTERNAL_ERROR = "internal_error",
+	SERVICE_UNAVAILABLE = "service_unavailable",
+	DISCOVERY_FAILED = "discovery_failed",
+	TRANSPORT_ERROR = "transport_error",
+	WORKER_ERROR = "worker_error",
+	UPLOAD_FAILED = "upload_failed",
+	VAD_ERROR = "vad_error"
+}
+export declare enum HttpStatus {
+	OK = 200,
+	CREATED = 201,
+	ACCEPTED = 202,
+	BAD_REQUEST = 400,
+	UNAUTHORIZED = 401,
+	FORBIDDEN = 403,
+	NOT_FOUND = 404,
+	GONE = 410,
+	PAYLOAD_TOO_LARGE = 413,
+	UNPROCESSABLE_ENTITY = 422,
+	TOO_MANY_REQUESTS = 429,
+	INTERNAL_SERVER_ERROR = 500,
+	SERVICE_UNAVAILABLE = 503
+}
+export declare class ScribeError extends Error {
+	readonly code: ErrorCode | string;
+	readonly httpStatus?: number;
+	readonly details?: Record<string, any>;
+	constructor(message: string, code?: ErrorCode | string, httpStatus?: number, details?: Record<string, any>);
+	static fromApiError(apiError: ApiError, httpStatus?: number): ScribeError;
+	toJSON(): Record<string, any>;
+}
+export declare class ValidationError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class DiscoveryError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class AuthenticationError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class ForbiddenError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class SessionNotFoundError extends ScribeError {
+	constructor(sessionId: string);
+}
+export declare class SessionExpiredError extends ScribeError {
+	constructor(sessionId: string, expiredAt?: string);
+}
+export declare class RateLimitError extends ScribeError {
+	constructor(retryAfter?: number);
+}
+export declare class TransportError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class WorkerError extends ScribeError {
+	constructor(message: string, details?: Record<string, any>);
+}
+export declare class UploadError extends ScribeError {
+	readonly failedFiles: string[];
+	constructor(message: string, failedFiles: string[], details?: Record<string, any>);
+	toJSON(): Record<string, any>;
+}
+export interface ApiError {
+	code: ErrorCode | string;
+	message: string;
+	details?: Record<string, any>;
+}
+export interface ErrorResponse {
+	error: ApiError;
+}
 /**
- * Scribe EMR Protocol SDK
- * TypeScript SDK for the MedScribe Alliance Protocol
+ * Result type for all public SDK methods.
+ * Expected errors (API failures, auth, validation) are returned — not thrown.
+ */
+export type SDKResult<T = void> = {
+	success: true;
+	data: T;
+} | {
+	success: false;
+	error: ScribeError;
+};
+/**
+ * Transport layer types
+ */
+export interface TransportRequest {
+	method: "GET" | "POST" | "PUT" | "DELETE";
+	url: string;
+	headers?: Record<string, string>;
+	body?: any;
+	isUpload?: boolean;
+	uploadBlob?: Blob;
+	/** Additional HTTP status codes to treat as success (not throw). */
+	acceptStatuses?: number[];
+}
+export interface TransportResponse<T = any> {
+	status: number;
+	headers: Record<string, string>;
+	data: T;
+}
+export interface ITransport {
+	request<T = any>(config: TransportRequest): Promise<TransportResponse<T>>;
+	setAuthToken(token: string): void;
+	/** Clean up pending requests and resources. */
+	destroy?(): void;
+}
+/**
+ * IPC bridge provided by the consumer (e.g. Electron host)
+ */
+export interface IpcBridge {
+	send: (request: IpcRequest) => void;
+	onResponse: (handler: (response: IpcResponse) => void) => void;
+}
+export interface IpcRequest {
+	correlationId: string;
+	method: string;
+	url: string;
+	headers?: Record<string, string>;
+	body?: any;
+	/** Base64-encoded blob data for uploads */
+	blobData?: string;
+}
+export interface IpcResponse {
+	correlationId: string;
+	status: number;
+	headers: Record<string, string>;
+	body: any;
+	error?: string;
+}
+export interface ScribeSDKConfig {
+	/** Base URL of the scribe service (required) */
+	baseUrl: string;
+	/** Bearer token authentication */
+	accessToken?: string;
+	/** Transport mode: 'direct' (HTTP fetch) or 'ipc' (Electron IPC). Default: 'direct' */
+	mode?: TransportMode;
+	/** IPC bridge — required when mode is 'ipc' */
+	ipcTransport?: IpcBridge;
+	/** SharedWorker config: true (require), false (disable), 'auto' (detect). Default: 'auto' */
+	useWorker?: boolean | "auto";
+	/** URL to the worker.bundle.js file. Use getWorkerUrl() or createWorkerBlobUrl() to resolve. */
+	workerScriptUrl?: string;
+	/** Enable debug logging. Default: false */
+	debug?: boolean;
+	/** Auto-fetch discovery document on init. Default: true */
+	autoDiscovery?: boolean;
+}
+/**
+ * Discovery document types (MedScribe Alliance Protocol)
+ */
+export interface DiscoveryDocument {
+	protocol: string;
+	protocol_version: string;
+	supported_versions?: string[];
+	service?: ServiceInfo;
+	endpoints: EndpointsInfo;
+	authentication: AuthenticationInfo;
+	capabilities: CapabilitiesInfo;
+	models?: ModelConfig[];
+	languages: LanguagesInfo;
+}
+export interface ServiceInfo {
+	name?: string;
+	documentation_url?: string;
+	support_email?: string;
+}
+export interface EndpointsInfo {
+	base_url: string;
+	webhooks_url?: string;
+	authorization_endpoint?: string;
+	token_endpoint?: string;
+}
+export interface AuthenticationInfo {
+	supported_methods: string[];
+	oidc?: {
+		issuer: string;
+		authorization_endpoint: string;
+		token_endpoint: string;
+		scopes_supported: string[];
+	};
+}
+export interface CapabilitiesInfo {
+	audio_formats: string[];
+	max_chunk_duration_seconds: number;
+	upload_methods?: string[];
+	webhook_delivery?: boolean;
+	client_sdk_delivery?: boolean;
+}
+export interface ModelConfig {
+	id: string;
+	display_name?: string;
+	languages?: string[];
+	max_session_duration_seconds: number;
+	response_speed?: string;
+	features?: {
+		realtime_transcription?: boolean;
+		speaker_diarization?: boolean;
+		custom_templates?: boolean;
+	};
+}
+export interface LanguagesInfo {
+	supported: string[];
+	auto_detection?: boolean;
+}
+/**
+ * Parsed runtime configuration derived from DiscoveryDocument.
+ * Used by all layers at runtime for validation and configuration.
+ */
+export interface ResolvedConfig {
+	baseUrl: string;
+	webhooksUrl?: string;
+	supportedLanguages: string[];
+	autoDetectLanguage: boolean;
+	supportedAudioFormats: string[];
+	supportedUploadMethods: string[];
+	maxChunkDurationSeconds: number;
+	/** modelId -> max session duration in seconds */
+	maxSessionDurationSeconds: Map<string, number>;
+	supportedAuthMethods: string[];
+	availableModels: ModelConfig[];
+	webhookDelivery: boolean;
+	clientSdkDelivery: boolean;
+}
+export interface CreateSessionRequest {
+	templates: string[];
+	model?: string;
+	language_hint?: string[];
+	transcript_language?: string[];
+	upload_type: string;
+	communication_protocol: string;
+	additional_data?: Record<string, any>;
+}
+export interface CreateSessionResponse {
+	session_id: string;
+	status: SessionStatus;
+	created_at: string;
+	expires_at: string;
+	upload_url: string;
+}
+export interface EndSessionRequest {
+	audio_files_sent: number;
+}
+export interface EndSessionResponse {
+	session_id: string;
+	status: SessionStatus;
+	message: string;
+	audio_files_received: number;
+	audio_files: string[];
+}
+export interface GetSessionStatusResponse {
+	session_id: string;
+	status: SessionStatus;
+	created_at: string;
+	expires_at?: string;
+	completed_at?: string;
+	model_used?: string;
+	language_detected?: string;
+	audio_files_received?: number;
+	audio_files?: string[];
+	audio_files_processed?: number;
+	additional_data?: Record<string, any>;
+	templates?: TemplatesOutput;
+	transcript?: string;
+	processing_errors?: ProcessingError[];
+	error?: {
+		code: string;
+		message: string;
+		details?: Record<string, any>;
+	};
+}
+export interface TemplatesOutput {
+	[templateId: string]: TemplateEntry;
+}
+export interface TemplateEntry {
+	status: TemplateStatus;
+	data?: any;
+	fhir?: any;
+	error?: TemplateError;
+}
+export interface TemplateError {
+	code: string;
+	message: string;
+}
+export interface ProcessingError {
+	type: string;
+	message: string;
+	file?: string;
+}
+export interface PollOptions {
+	maxAttempts?: number;
+	intervalMs?: number;
+	onProgress?: (status: GetSessionStatusResponse) => void;
+}
+export interface RecordingOptions {
+	templates: string[];
+	model?: string;
+	languageHint?: string[];
+	transcriptLanguage?: string[];
+	uploadType?: string;
+	communicationProtocol?: string;
+	additionalData?: Record<string, any>;
+	deviceId?: string;
+}
+export interface RecorderConfig {
+	accessToken?: string;
+	uploadUrl: string;
+	uploadHeaders: Record<string, string>;
+	sessionId: string;
+}
+export interface IRecorder {
+	initialize(session: CreateSessionResponse, config: RecorderConfig): void;
+	start(deviceId?: string): Promise<void>;
+	pause(): void;
+	resume(): void;
+	stop(): Promise<StopRecordingResult>;
+	reset(): void;
+	isPaused(): boolean;
+}
+export interface StopRecordingResult {
+	failedUploads: string[];
+	totalFiles: number;
+}
+/**
+ * Audio chunk metadata tracked by AudioFileManager
+ */
+export type AudioChunkInfo = {
+	fileName: string;
+	timestamp: {
+		st: string;
+		et: string;
+	};
+	response?: string;
+} & ({
+	status: "pending";
+	audioFrames: Float32Array;
+	fileBlob?: undefined;
+} | {
+	status: "success";
+	audioFrames?: undefined;
+	fileBlob?: undefined;
+} | {
+	status: "failure";
+	fileBlob: Blob;
+	audioFrames?: undefined;
+});
+export interface RetryUploadResult {
+	/** Number of files retried */
+	retried: number;
+	/** Number that succeeded on retry */
+	succeeded: number;
+	/** File names that still failed after retry */
+	stillFailed: string[];
+}
+type RecordingState$1 = "started" | "paused" | "resumed" | "ended";
+export interface RecordingStateChangeEvent {
+	type: RecordingState$1;
+	timestamp: string;
+	data?: any;
+}
+export type AudioEventType = "user_speech" | "silence_warning" | "chunk_ready" | "frame_processed";
+export interface AudioEventUserSpeech {
+	type: "user_speech";
+	timestamp: string;
+	data: {
+		isSpeaking: boolean;
+	};
+}
+export interface AudioEventSilenceWarning {
+	type: "silence_warning";
+	timestamp: string;
+	data: {
+		durationMs: number;
+	};
+}
+export interface AudioEventChunkReady {
+	type: "chunk_ready";
+	timestamp: string;
+	data: {
+		chunkIndex: number;
+		fileName: string;
+	};
+}
+export interface AudioEventFrameProcessed {
+	type: "frame_processed";
+	timestamp: string;
+	data: {
+		isSpeech: number;
+		notSpeech: number;
+	};
+}
+export type AudioEvent = AudioEventUserSpeech | AudioEventSilenceWarning | AudioEventChunkReady | AudioEventFrameProcessed;
+export type UploadEventType = "progress" | "failed" | "retry";
+export interface UploadEventProgress {
+	type: "progress";
+	timestamp: string;
+	data: {
+		successCount: number;
+		totalCount: number;
+	};
+}
+export interface UploadEventFailed {
+	type: "failed";
+	timestamp: string;
+	data: {
+		fileName: string;
+		error: string;
+	};
+}
+export interface UploadEventRetry {
+	type: "retry";
+	timestamp: string;
+	data: {
+		fileName: string;
+		attempt: number;
+	};
+}
+export type UploadEvent = UploadEventProgress | UploadEventFailed | UploadEventRetry;
+export type SessionEventType = "created" | "ended" | "status_update" | "partial_result";
+export interface SessionEventCreated {
+	type: "created";
+	timestamp: string;
+	data: CreateSessionResponse;
+}
+export interface SessionEventEnded {
+	type: "ended";
+	timestamp: string;
+	data: EndSessionResponse;
+}
+export interface SessionEventStatusUpdate {
+	type: "status_update";
+	timestamp: string;
+	data: GetSessionStatusResponse;
+}
+export interface SessionEventPartialResult {
+	type: "partial_result";
+	timestamp: string;
+	data: any;
+}
+export type SessionEvent = SessionEventCreated | SessionEventEnded | SessionEventStatusUpdate | SessionEventPartialResult;
+export type ErrorEventType = "vad_error" | "worker_error" | "transport_error" | "validation_error";
+interface ErrorEvent$1 {
+	type: ErrorEventType;
+	timestamp: string;
+	error: {
+		code: string;
+		message: string;
+		details?: any;
+	};
+}
+export interface TokenRequiredEvent {
+	resolve: (newToken: string) => void;
+}
+export interface CallbackMap {
+	onRecordingStateChange: (event: RecordingStateChangeEvent) => void;
+	onAudioEvent: (event: AudioEvent) => void;
+	onUploadEvent: (event: UploadEvent) => void;
+	onSessionEvent: (event: SessionEvent) => void;
+	onError: (event: ErrorEvent$1) => void;
+	onTokenRequired: (event: TokenRequiredEvent) => void;
+}
+export type CallbackName = keyof CallbackMap;
+/**
+ * SharedWorker message protocol types
+ */
+export interface WorkerCompressAndUploadMessage {
+	type: "compress_and_upload";
+	audioFrames: Float32Array;
+	fileName: string;
+	uploadUrl: string;
+	headers: Record<string, string>;
+}
+export interface WorkerWaitForUploadsMessage {
+	type: "wait_for_all_uploads";
+}
+export interface WorkerUpdateTokenMessage {
+	type: "update_auth_token";
+	token: string;
+}
+export interface WorkerTerminateMessage {
+	type: "terminate";
+}
+export type MainToWorkerMessage = WorkerCompressAndUploadMessage | WorkerWaitForUploadsMessage | WorkerUpdateTokenMessage | WorkerTerminateMessage;
+export interface WorkerUploadSuccessMessage {
+	type: "upload_success";
+	fileName: string;
+}
+export interface WorkerUploadFailedMessage {
+	type: "upload_failed";
+	fileName: string;
+	error: string;
+	blob?: Blob;
+}
+export interface WorkerAllUploadsCompleteMessage {
+	type: "all_uploads_complete";
+}
+export interface WorkerTokenRequiredMessage {
+	type: "token_required";
+}
+export type WorkerToMainMessage = WorkerUploadSuccessMessage | WorkerUploadFailedMessage | WorkerAllUploadsCompleteMessage | WorkerTokenRequiredMessage;
+export declare class ScribeClient {
+	private config;
+	private transport;
+	private callbackRegistry;
+	private validator;
+	private discoveryManager;
+	private sessionManager;
+	private recordingManager;
+	private isInitialized;
+	constructor(config: ScribeSDKConfig);
+	/**
+	 * Initialize the SDK — fetches the discovery document if autoDiscovery is enabled.
+	 * Must be called before starting a recording.
+	 */
+	init(): Promise<SDKResult<void>>;
+	/**
+	 * Start a recording session.
+	 * Calls init() automatically if not already initialized.
+	 */
+	startRecording(options: RecordingOptions): Promise<SDKResult<CreateSessionResponse>>;
+	/**
+	 * Start recording for an already-created session.
+	 * Use this when the session was created via createSession() and you want
+	 * to attach a recorder to it.
+	 *
+	 * @param session - The session response from createSession()
+	 * @param options - Upload type ('chunked' | 'single') and optional deviceId
+	 */
+	startRecordingWithSession(session: CreateSessionResponse, options?: {
+		uploadType?: string;
+		deviceId?: string;
+	}): Promise<SDKResult<void>>;
+	/**
+	 * Pause the active recording.
+	 */
+	pauseRecording(): void;
+	/**
+	 * Resume a paused recording.
+	 */
+	resumeRecording(): void;
+	/**
+	 * End the active recording — stops recorder, waits for uploads, ends session.
+	 */
+	endRecording(): Promise<SDKResult<StopRecordingResult>>;
+	/**
+	 * Retry uploading audio files that failed during the last recording.
+	 * Only available after endRecording() returned failed uploads.
+	 * Cleared on reset() or next startRecording().
+	 */
+	retryFailedUploads(): Promise<SDKResult<RetryUploadResult>>;
+	/**
+	 * Check if there are failed uploads from the last recording that can be retried.
+	 */
+	hasFailedUploads(): boolean;
+	/**
+	 * Check if a recording is currently active.
+	 */
+	isRecording(): boolean;
+	/**
+	 * Check if the active recording is paused.
+	 */
+	isRecordingPaused(): boolean;
+	/**
+	 * Create a session directly (without starting a recording).
+	 */
+	createSession(sessionRequest: CreateSessionRequest): Promise<SDKResult<CreateSessionResponse>>;
+	/**
+	 * Get the status of a session.
+	 * Uses the current active session if no sessionId is provided.
+	 *
+	 * Pass `poll` options to keep checking until the session reaches a
+	 * terminal state (completed, partial, failed, expired) or times out.
+	 *
+	 */
+	getSessionStatus(sessionId?: string, options?: {
+		poll?: PollOptions;
+	}): Promise<SDKResult<GetSessionStatusResponse>>;
+	/**
+	 * Get the current active session, if any.
+	 */
+	getCurrentSession(): CreateSessionResponse | null;
+	/**
+	 * Get the resolved discovery config.
+	 * Returns error if discovery hasn't been fetched yet.
+	 */
+	getDiscoveryConfig(): SDKResult<ResolvedConfig>;
+	/**
+	 * Get the raw discovery document.
+	 */
+	getDiscoveryDocument(): DiscoveryDocument | null;
+	/**
+	 * Force refresh the discovery document.
+	 */
+	refreshDiscovery(): Promise<SDKResult<ResolvedConfig>>;
+	/**
+	 * Register a callback handler.
+	 *
+	 * @example
+	 * client.registerCallback('onAudioEvent', (event) => {
+	 *   if (event.type === 'user_speech') console.log('Speaking:', event.data.isSpeaking);
+	 * });
+	 */
+	registerCallback<K extends CallbackName>(name: K, handler: CallbackMap[K]): void;
+	/**
+	 * Remove a previously registered callback handler.
+	 */
+	removeCallback<K extends CallbackName>(name: K, handler: CallbackMap[K]): void;
+	/**
+	 * Update the Bearer token. Propagates to transport, active recorder, and worker.
+	 */
+	setAccessToken(token: string): void;
+	/**
+	 * Full reset — stops recording if active, clears all caches and state.
+	 */
+	reset(): Promise<void>;
+	/**
+	 * Wraps an async operation into SDKResult.
+	 * Internal layers throw — this converts to { success, data/error }.
+	 */
+	private wrapResult;
+	/**
+	 * Ensures any error is a ScribeError instance.
+	 */
+	private toScribeError;
+	/**
+	 * Create the transport layer (HTTP or IPC) with 401 auto-retry wiring.
+	 *
+	 * How 401 auto-retry works:
+	 * 1. Transport gets a 401 response → calls onUnauthorized()
+	 * 2. onUnauthorized dispatches the 'onTokenRequired' callback to the consumer
+	 * 3. Consumer calls resolve(newToken) → token is propagated via setAccessToken()
+	 * 4. Promise resolves with the new token → transport retries the request once
+	 *
+	 * Deduplication: Transport holds a single tokenRefreshPromise — if multiple
+	 * requests get 401 concurrently, they all await the same promise, so only
+	 * ONE onTokenRequired callback fires regardless of how many requests failed.
+	 *
+	 * Timeout: If no handler is registered or the consumer never calls resolve(),
+	 * the promise resolves with undefined after 10s → transport skips retry.
+	 */
+	private createTransport;
+	private resolveWorkerConfig;
+	/**
+	 * Get the effective base URL — prefer discovery's base_url, fall back to config.
+	 */
+	private getEffectiveBaseUrl;
+	private validateConfig;
+}
+export declare class CallbackRegistry {
+	private handlers;
+	/**
+	 * Register a handler for a callback name.
+	 * The same handler reference won't be added twice.
+	 */
+	register<K extends CallbackName>(name: K, handler: CallbackMap[K]): void;
+	/**
+	 * Remove a previously registered handler.
+	 */
+	remove<K extends CallbackName>(name: K, handler: CallbackMap[K]): void;
+	/**
+	 * Remove all handlers for a specific callback name,
+	 * or all handlers entirely if no name is provided.
+	 */
+	removeAll(name?: CallbackName): void;
+	/**
+	 * Dispatch an event to all registered handlers for the given callback name.
+	 * Each handler is invoked in a try/catch — one failing handler does not
+	 * prevent other handlers from executing.
+	 */
+	dispatch<K extends CallbackName>(name: K, event: Parameters<CallbackMap[K]>[0]): void;
+	/**
+	 * Check if any handlers are registered for a callback name.
+	 */
+	hasHandlers(name: CallbackName): boolean;
+}
+export declare class Validator {
+	validateDiscoveryResponse(data: unknown): void;
+	validateCreateSessionRequest(data: unknown): void;
+	validateEndSessionRequest(data: unknown): void;
+	validateCreateSessionResponse(data: unknown): void;
+	validateEndSessionResponse(data: unknown): void;
+	validateGetSessionStatusResponse(data: unknown): void;
+	validateSessionId(sessionId: unknown): void;
+	validateRecordingOptions(data: unknown): void;
+	/**
+	 * Cross-validates recording options against the server's declared capabilities.
+	 * Throws ValidationError with a descriptive message if any check fails.
+	 */
+	validateAgainstDiscovery(options: RecordingOptions, config: ResolvedConfig): void;
+	/**
+	 * Parses data against a Zod schema. On failure, converts ZodError
+	 * into our ValidationError with a human-readable message.
+	 */
+	private parseWithValidationError;
+	private formatZodIssues;
+	private checkUploadType;
+	private checkLanguageHint;
+	private checkModel;
+}
+export declare class DiscoveryManager {
+	private transport;
+	private validator;
+	private debug;
+	private cachedDocument;
+	private resolvedConfig;
+	private cacheTimestamp;
+	private cacheTtlMs;
+	constructor(transport: ITransport, validator: Validator, debug?: boolean);
+	/**
+	 * Fetch and validate the discovery document from the well-known endpoint.
+	 * Caches the result for 1 hour (configurable).
+	 */
+	fetchDiscovery(baseUrl: string, forceRefresh?: boolean): Promise<ResolvedConfig>;
+	/**
+	 * Get the resolved runtime config. Throws if discovery hasn't been fetched.
+	 */
+	getResolvedConfig(): ResolvedConfig;
+	/**
+	 * Get the raw discovery document as received from the server.
+	 */
+	getDiscoveryDocument(): DiscoveryDocument | null;
+	getSupportedLanguages(): string[];
+	getSupportedAudioFormats(): string[];
+	getSupportedUploadMethods(): string[];
+	getAvailableModels(): ModelConfig[];
+	getMaxChunkDuration(): number;
+	getMaxSessionDuration(modelId?: string): number;
+	getServiceInfo(): ServiceInfo | undefined;
+	getCapabilities(): CapabilitiesInfo | undefined;
+	isFeatureSupported(feature: "realtime_transcription" | "speaker_diarization" | "custom_templates"): boolean;
+	clearCache(): void;
+	private isCacheValid;
+}
+export declare class SessionManager {
+	private transport;
+	private validator;
+	private debug;
+	private currentSession;
+	constructor(transport: ITransport, validator: Validator, debug?: boolean);
+	/**
+	 * Create a new scribe session.
+	 * Validates the request structure, sends to server, validates response.
+	 */
+	createSession(baseUrl: string, request: CreateSessionRequest): Promise<CreateSessionResponse>;
+	/**
+	 * End an active session.
+	 * If no sessionId is provided, ends the current session.
+	 */
+	endSession(baseUrl: string, request: EndSessionRequest, sessionId?: string): Promise<EndSessionResponse>;
+	/**
+	 * Get the status of a session.
+	 * If no sessionId is provided, queries the current session.
+	 */
+	getSessionStatus(baseUrl: string, sessionId?: string): Promise<GetSessionStatusResponse>;
+	/**
+	 * Poll for session completion.
+	 * Keeps checking getSessionStatus until the session reaches a terminal state
+	 * (completed, partial, or failed) or the max attempts are exhausted.
+	 */
+	pollForCompletion(baseUrl: string, sessionId?: string, options?: PollOptions): Promise<GetSessionStatusResponse>;
+	/**
+	 * Get the current active session, if any.
+	 */
+	getCurrentSession(): CreateSessionResponse | null;
+	/**
+	 * Clear the current session reference.
+	 * Used when recording is stopped or session is explicitly cleared.
+	 */
+	clearCurrentSession(): void;
+	/**
+	 * Check if a session status is terminal (no more processing will happen).
+	 */
+	private isTerminalStatus;
+	private sleep;
+}
+export interface WorkerManagerConfig {
+	/** Path to the compiled shared-worker.js bundle. Required for SharedWorker mode. */
+	workerScriptUrl?: string;
+	/** If true, skip SharedWorker and always run on main thread via ITransport. */
+	forceMainThread?: boolean;
+}
+export interface RecordingManagerConfig {
+	workerConfig?: WorkerManagerConfig;
+	debug?: boolean;
+}
+export declare class RecordingManager {
+	private callbackRegistry;
+	private sessionManager;
+	private discoveryManager;
+	private transport;
+	private config;
+	private recorder;
+	private activeSession;
+	private activeBaseUrl;
+	private _isRecording;
+	private _isStarting;
+	private retryContext;
+	constructor(callbackRegistry: CallbackRegistry, sessionManager: SessionManager, discoveryManager: DiscoveryManager, transport: ITransport, config?: RecordingManagerConfig);
+	/**
+	 * Start a recording session:
+	 * 1. Map RecordingOptions → CreateSessionRequest
+	 * 2. Create session via SessionManager
+	 * 3. Create and initialize the appropriate recorder
+	 * 4. Start recording
+	 * 5. Dispatch events
+	 *
+	 * @param baseUrl - Server base URL (from discovery or SDK config)
+	 * @param options - Recording options (templates, model, etc.)
+	 * @param accessToken - Current Bearer token for upload auth headers
+	 * @returns The created session response
+	 */
+	start(baseUrl: string, options: RecordingOptions, accessToken?: string): Promise<CreateSessionResponse>;
+	/**
+	 * Start recording for an already-created session.
+	 * Use this when the session was created externally (e.g. via createSession())
+	 * and you want to attach a recorder to it.
+	 *
+	 * @param baseUrl - Server base URL for ending session later
+	 * @param session - The existing session response (must have upload_url)
+	 * @param options - Upload type and optional device ID
+	 * @param accessToken - Current Bearer token for upload auth headers
+	 */
+	startWithExistingSession(baseUrl: string, session: CreateSessionResponse, options?: {
+		uploadType?: string;
+		deviceId?: string;
+	}, accessToken?: string): Promise<void>;
+	/**
+	 * Pause the active recording.
+	 */
+	pause(): void;
+	/**
+	 * Resume a paused recording.
+	 */
+	resume(): void;
+	/**
+	 * Stop the active recording:
+	 * 1. Stop recorder (flushes remaining audio, waits for uploads)
+	 * 2. End session via SessionManager (sends audio_files_sent count)
+	 * 3. Clean up state
+	 * 4. Dispatch events
+	 *
+	 * @returns Stop result with failed uploads and total files
+	 */
+	stop(): Promise<StopRecordingResult>;
+	/**
+	 * Update the auth token for the active recording.
+	 * Forwards to the active recorder (which updates WorkerManager/transport).
+	 */
+	updateAuthToken(token: string): void;
+	/**
+	 * Reset everything — force-stops if recording, clears state.
+	 */
+	reset(): void;
+	isRecording(): boolean;
+	isPaused(): boolean;
+	getActiveSession(): CreateSessionResponse | null;
+	/**
+	 * Check if there are failed uploads from the last recording that can be retried.
+	 */
+	hasFailedUploads(): boolean;
+	/**
+	 * Retry uploading audio files that failed during the last recording.
+	 * Uses the stored MP3 blobs and the original upload URL.
+	 *
+	 * Each file is re-uploaded via transport.request() with retry logic.
+	 * Successfully retried files are removed from the retry context.
+	 */
+	retryFailedUploads(): Promise<RetryUploadResult>;
+	/**
+	 * Create the appropriate recorder based on upload type.
+	 */
+	private createRecorder;
+	/**
+	 * Build upload headers from the current auth state.
+	 */
+	private buildUploadHeaders;
+	/**
+	 * Apply discovery-driven overrides to ChunkedRecorder's VAD config.
+	 * For example, max_chunk_duration_seconds from discovery overrides the default.
+	 */
+	private applyDiscoveryOverrides;
+	/**
+	 * Dispatch an error event for a specific start() step failure.
+	 */
+	private dispatchStartError;
+	/**
+	 * Extract failed chunks with their MP3 blobs from the recorder's FileManager
+	 * before cleanup destroys the recorder state.
+	 */
+	private preserveRetryContext;
+	/**
+	 * Clean up recording state after stop or error.
+	 */
+	private cleanupRecordingState;
+}
+export declare class HttpTransport implements ITransport {
+	private accessToken?;
+	private debug;
+	private onUnauthorized?;
+	private tokenRefreshPromise;
+	constructor(options: {
+		accessToken?: string;
+		debug?: boolean;
+		onUnauthorized?: () => Promise<string | undefined>;
+	});
+	setAuthToken(token: string): void;
+	request<T = any>(config: TransportRequest): Promise<TransportResponse<T>>;
+	private executeRequest;
+	/**
+	 * Execute a single fetch call with current auth headers.
+	 */
+	private doFetch;
+	/**
+	 * Deduplicated token refresh.
+	 * If multiple requests get 401 simultaneously, only one onTokenRequired
+	 * callback fires — the rest await the same promise.
+	 */
+	private refreshToken;
+	private buildHeaders;
+	private buildRequestInit;
+	private buildSuccessResponse;
+	/**
+	 * Maps HTTP error responses to typed SDK errors and throws.
+	 * 401 is NOT handled here — it's handled in executeRequest with auto-retry.
+	 */
+	private handleErrorResponse;
+	private extractHeaders;
+	private getRetryOptions;
+}
+export declare class IpcTransport implements ITransport {
+	private bridge;
+	private pendingRequests;
+	private accessToken?;
+	private debug;
+	private correlationCounter;
+	private onUnauthorized?;
+	private tokenRefreshPromise;
+	constructor(options: {
+		bridge: IpcBridge;
+		accessToken?: string;
+		debug?: boolean;
+		onUnauthorized?: () => Promise<string | undefined>;
+	});
+	setAuthToken(token: string): void;
+	request<T = any>(config: TransportRequest): Promise<TransportResponse<T>>;
+	private executeRequest;
+	/**
+	 * Execute a single IPC request with current auth headers.
+	 */
+	private doIpcRequest;
+	/**
+	 * Deduplicated token refresh.
+	 * If multiple requests get 401 simultaneously, only one onTokenRequired
+	 * callback fires — the rest await the same promise.
+	 */
+	private refreshToken;
+	private buildHeaders;
+	private buildIpcRequest;
+	private sendAndWait;
+	private handleResponse;
+	/**
+	 * Maps IPC error responses to typed SDK errors and throws.
+	 * 401 is NOT handled here — it's handled in executeRequest with auto-retry.
+	 */
+	private handleErrorResponse;
+	private generateCorrelationId;
+	private uint8ArrayToBase64;
+	private getRetryOptions;
+	/**
+	 * Clean up pending requests (e.g. on SDK reset).
+	 */
+	destroy(): void;
+}
+/**
+ * Returns the best-guess URL for the SharedWorker bundle.
+ *
+ * @example
+ * ```ts
+ * import { ScribeClient, getWorkerUrl } from 'med-scribe-alliance-ts-sdk';
+ *
+ * const client = new ScribeClient({
+ *   baseUrl: 'https://api.example.com',
+ *   workerScriptUrl: getWorkerUrl(),
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Global override (set before SDK loads)
+ * window.__MEDSCRIBE_WORKER_URL__ = '/assets/worker.bundle.js';
+ * ```
+ *
+ * @example
+ * ```ts
+ * // CDN blob URL (works around CORS restrictions on SharedWorker)
+ * const workerUrl = await createWorkerBlobUrl();
+ * ```
+ */
+export declare function getWorkerUrl(): string;
+/**
+ * Fetches the worker script from a URL and creates a blob URL.
+ * Useful when the worker file is on a CDN (SharedWorker requires same-origin).
+ *
+ * @param url - URL to fetch the worker script from.
+ *              Defaults to jsDelivr CDN for this package.
+ * @returns A blob URL that can be used as workerScriptUrl
  *
- * @packageDocumentation
+ * @example
+ * ```ts
+ * const workerUrl = await createWorkerBlobUrl();
+ * const client = new ScribeClient({
+ *   baseUrl: 'https://api.example.com',
+ *   workerScriptUrl: workerUrl,
+ * });
+ * ```
  */
-export { ScribeClient, getScribeInstance } from './client';
-export type { ScribeSDKConfig, RecordingOptions, DiscoveryDocument, CreateSessionResponse, GetSessionStatusResponse, EndSessionResponse, TemplatesOutput, TemplateEntry, ApiError, SDKEvent, SDKEventType, ServiceInfo, EndpointsInfo, AuthenticationInfo, CapabilitiesInfo, ModelConfig, LanguagesInfo, CreateSessionRequest, TemplateError, ProcessingError, ErrorResponse, } from './types';
-export { SessionStatus, TemplateStatus, UploadType, ErrorCode, HttpStatus } from './constants';
-export { ScribeError, AuthenticationError, SessionNotFoundError, SessionExpiredError, RateLimitError, ValidationError, } from './utils/errors';
-export { schemaValidator } from './utils/validator';
-//# sourceMappingURL=index.d.ts.map
+export declare function createWorkerBlobUrl(url?: string): Promise<string>;
+
+export {
+	ErrorEvent$1 as ErrorEvent,
+	RecordingState$1 as RecordingState,
+};
+
+export {};