med-scribe-alliance-ts-sdk 1.0.1

package/README.md

@@ -0,0 +1,382 @@
+
+# Scribe EMR Protocol SDK
+
+A TypeScript SDK for the [MedScribe Alliance Protocol](https://github.com/MedScribeAlliance/scribe-emr-protocol), providing a clean and type-safe interface for medical transcription services.
+
+## Features
+
+- ✅ **Protocol Compliant**: Fully implements the MedScribe Alliance Protocol specification
+- ✅ **Type-Safe**: Complete TypeScript definitions for all API interactions
+- ✅ **Auto-Discovery**: Automatic service capability discovery via well-known endpoint
+- ✅ **Schema Validation**: AJV-powered validation against OpenAPI schemas
+- ✅ **Error Handling**: Comprehensive error handling with typed error codes
+- ✅ **Event System**: Built-in event emitter for session lifecycle events
+- ✅ **Polling Support**: Automatic polling for session completion
+
+## Installation
+
+```bash
+npm install scribe-standard-sdk
+```
+
+## Quick Start
+
+```typescript
+import { ScribeClient } from 'scribe-standard-sdk';
+
+// Initialize the SDK
+const client = new ScribeClient({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://api.scribe.example.com',
+  debug: true, // Optional: enable debug logging
+});
+
+// Initialize (performs discovery)
+await client.init();
+
+// Start a recording session
+const session = await client.startRecording({
+  templates: ['soap', 'medications'],
+  languageHint: ['en'],
+  model: 'pro',
+});
+
+console.log('Session created:', session.session_id);
+console.log('Upload audio to:', session.upload_url);
+
+// ... Upload audio chunks to session.upload_url ...
+
+// End the recording session
+const endResponse = await client.endRecording();
+console.log('Session ended, processing started');
+
+// Poll for completion
+const result = await client.pollForCompletion(session.session_id, {
+  maxAttempts: 60,
+  intervalMs: 2000,
+  onProgress: (status) => {
+    console.log('Status:', status.status);
+  },
+});
+
+// Access the results
+if (result.status === 'completed') {
+  console.log('Transcript:', result.transcript);
+  console.log('Templates:', result.templates);
+}
+```
+
+## Core API
+
+### ScribeClient
+
+The main SDK client class.
+
+#### Constructor
+
+```typescript
+new ScribeClient(config: ScribeSDKConfig)
+```
+
+**Config Options:**
+- `apiKey` (required): Your API key for authentication
+- `baseUrl` (optional): Base URL of the Scribe service
+- `debug` (optional): Enable debug logging (default: `false`)
+- `autoDiscovery` (optional): Auto-fetch service capabilities (default: `true`)
+
+#### Methods
+
+##### `init(): Promise<void>`
+
+Initialize the SDK and perform service discovery.
+
+```typescript
+await client.init();
+```
+
+##### `startRecording(options: RecordingOptions): Promise<CreateSessionResponse>`
+
+Start a new recording session.
+
+**Options:**
+- `templates` (required): Array of template IDs to extract (e.g., `['soap', 'medications']`)
+- `model` (optional): Model ID from discovery
+- `languageHint` (optional): Array of ISO 639-1 language codes for audio input (e.g., `['en', 'es']`)
+- `transcriptLanguage` (optional): Array of ISO 639-1 codes for transcript output (e.g., `['en']`)
+- `uploadType` (optional): `'chunked'` or `'single'`
+- `communicationProtocol` (optional): `'http'`, `'websocket'`, or `'rpc'` (default: `'http'`)
+- `additionalData` (optional): Pass-through data for your application
+
+**Returns:**
+- `session_id`: Unique session identifier
+- `status`: Session status (`'created'`)
+- `created_at`: ISO 8601 timestamp
+- `expires_at`: ISO 8601 expiry timestamp
+- `upload_url`: URL for uploading audio
+
+```typescript
+const session = await client.startRecording({
+  templates: ['soap'],
+  languageHint: ['en'],
+  transcriptLanguage: ['en'],
+  additionalData: {
+    patient_id: 'pat_123',
+    encounter_id: 'enc_456',
+  },
+});
+```
+
+##### `endRecording(): Promise<EndSessionResponse>`
+
+End the current recording session and trigger processing.
+
+```typescript
+const response = await client.endRecording();
+```
+
+##### `getOutputStatus(sessionId?: string): Promise<GetSessionStatusResponse>`
+
+Get the current status and results of a session.
+
+```typescript
+const status = await client.getOutputStatus(session.session_id);
+
+if (status.status === 'completed') {
+  console.log('Transcript:', status.transcript);
+  console.log('Templates:', status.templates);
+}
+```
+
+**Session Status Values:**
+- `created`: Session created, awaiting audio
+- `processing`: Audio is being processed
+- `completed`: Processing complete, all templates successful
+- `partial`: Processing complete, some templates failed
+- `failed`: Processing failed completely
+
+##### `pollForCompletion(sessionId?, options?): Promise<GetSessionStatusResponse>`
+
+Poll for session completion with automatic retries.
+
+```typescript
+const result = await client.pollForCompletion(session.session_id, {
+  maxAttempts: 60,      // Maximum polling attempts
+  intervalMs: 2000,     // Interval between polls (ms)
+  onProgress: (status) => {
+    console.log('Current status:', status.status);
+  },
+});
+```
+
+##### `getCurrentSession(): CreateSessionResponse | null`
+
+Get the current active session.
+
+```typescript
+const currentSession = client.getCurrentSession();
+```
+
+##### `getDiscoveryDocument(): DiscoveryDocument | null`
+
+Get the cached discovery document.
+
+```typescript
+const discovery = client.getDiscoveryDocument();
+console.log('Supported models:', discovery?.models);
+console.log('Supported languages:', discovery?.languages.supported);
+```
+
+## Event System
+
+The SDK emits events for session lifecycle tracking.
+
+```typescript
+client.on('discovery:complete', (event) => {
+  console.log('Discovery complete:', event.data);
+});
+
+client.on('session:created', (event) => {
+  console.log('Session created:', event.data);
+});
+
+client.on('session:ended', (event) => {
+  console.log('Session ended:', event.data);
+});
+
+client.on('session:status_update', (event) => {
+  console.log('Status update:', event.data);
+});
+
+client.on('error', (event) => {
+  console.error('Error:', event.error);
+});
+```
+
+## Schema Validation
+
+The SDK automatically validates all API requests against the OpenAPI schema using AJV. This ensures that:
+
+- Request bodies conform to the expected structure
+- Required fields are present
+- Field types match the specification
+- Session IDs follow the correct pattern (`ses_[a-zA-Z0-9]+`)
+- Enum values are valid (e.g., `model`, `upload_type`, `communication_protocol`)
+
+Validation happens automatically before any API call:
+
+```typescript
+// This will throw a ValidationError if the request is invalid
+try {
+  const session = await client.startRecording({
+    templates: ['soap', 'medications'],
+    model: 'invalid-model', // ❌ Will fail validation if not in enum
+    uploadType: 'chunked',
+  });
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.error('Validation failed:', error.message);
+    // Example: "Validation failed for CreateSessionRequest:
+    //           - /model: must be equal to one of the allowed values (allowed values: pro, lite)"
+  }
+}
+```
+
+**Validated Operations:**
+- `createSession()`: Validates request body against `CreateSessionRequest` schema
+- `getSessionStatus()`: Validates session ID format
+- `endSession()`: Validates session ID format
+- `pollSessionStatus()`: Validates session ID format
+
+You can also use the validator directly for custom validation:
+
+```typescript
+import { schemaValidator } from 'scribe-standard-sdk/utils/validator';
+
+// Validate a session ID
+try {
+  schemaValidator.validateSessionId('ses_abc123');
+} catch (error) {
+  console.error('Invalid session ID:', error.message);
+}
+
+// Validate a create session request
+try {
+  schemaValidator.validateCreateSessionRequest({
+    templates: ['soap'],
+    upload_type: 'chunked',
+    communication_protocol: 'http',
+  });
+} catch (error) {
+  console.error('Invalid request:', error.message);
+}
+```
+
+## Error Handling
+
+The SDK provides typed error classes for different error scenarios:
+
+```typescript
+import {
+  ScribeError,
+  AuthenticationError,
+  SessionNotFoundError,
+  SessionExpiredError,
+  RateLimitError,
+  ValidationError,
+} from 'scribe-standard-sdk';
+
+try {
+  await client.startRecording({ templates: ['soap'] });
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.error('Validation error:', error.message);
+  } else if (error instanceof AuthenticationError) {
+    console.error('Authentication failed:', error.message);
+  } else if (error instanceof SessionExpiredError) {
+    console.error('Session expired:', error.details);
+  } else if (error instanceof RateLimitError) {
+    console.error('Rate limited, retry after:', error.details?.retry_after_seconds);
+  } else if (error instanceof ScribeError) {
+    console.error('Scribe error:', error.code, error.message);
+  }
+}
+```
+
+## Template Output
+
+When a session completes, the `templates` field contains the extracted data:
+
+```typescript
+const status = await client.getOutputStatus(sessionId);
+
+if (status.templates) {
+  // Check SOAP template
+  const soap = status.templates['soap'];
+  if (soap.status === 'success') {
+    console.log('SOAP Note:', soap.data);
+  } else {
+    console.error('SOAP extraction failed:', soap.error);
+  }
+
+  // Check medications template
+  const meds = status.templates['medications'];
+  if (meds.status === 'success') {
+    console.log('Medications:', meds.data);
+  }
+}
+```
+
+## Discovery Document
+
+The discovery document provides service capabilities:
+
+```typescript
+const discovery = client.getDiscoveryDocument();
+
+// Check supported audio formats
+console.log('Audio formats:', discovery.capabilities.audio_formats);
+
+// Check max chunk duration
+console.log('Max chunk duration:', discovery.capabilities.max_chunk_duration_seconds);
+
+// Check available models
+discovery.models.forEach((model) => {
+  console.log(`Model: ${model.id}`);
+  console.log(`  Languages: ${model.languages.join(', ')}`);
+  console.log(`  Max duration: ${model.max_session_duration_seconds}s`);
+  console.log(`  Features:`, model.features);
+});
+```
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides full type definitions:
+
+```typescript
+import type {
+  ScribeSDKConfig,
+  RecordingOptions,
+  CreateSessionResponse,
+  GetSessionStatusResponse,
+  TemplatesOutput,
+  DiscoveryDocument,
+} from 'scribe-standard-sdk';
+```
+
+## Protocol Compliance
+
+This SDK implements the following specifications:
+
+- **Spec 04**: Discovery - Service capability discovery via well-known endpoint
+- **Spec 06**: Session Lifecycle - Create, get status, and end sessions
+- **Spec 09**: Extraction & Response - Template output and transcript handling
+- **Spec 11**: Error Handling - Standard error codes and HTTP status mapping
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+

package/dist/api/base.d.ts

@@ -0,0 +1,43 @@
+/**
+ * HTTP Client for Scribe API
+ * Handles all HTTP communication with the Scribe service
+ */
+export interface RequestConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+}
+export declare class HttpClient {
+    private apiKey?;
+    private debug;
+    constructor(apiKey?: string, debug?: boolean);
+    /**
+     * Make an HTTP request
+     */
+    request<T>(url: string, config: RequestConfig): Promise<T>;
+    /**
+     * Handle error responses from the API
+     */
+    private handleErrorResponse;
+    /**
+     * GET request
+     */
+    get<T>(url: string, headers?: Record<string, string>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(url: string, body?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(url: string, body?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(url: string, body?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(url: string, headers?: Record<string, string>): Promise<T>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/api/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/api/base.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,KAAK,CAAU;gBAEX,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,OAAe;IAKnD;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC;IAkEhE;;OAEG;YACW,mBAAmB;IA0BjC;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIvE;;OAEG;IACG,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIpF;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAInF;;OAEG;IACG,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIrF;;OAEG;IACG,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAG3E"}

package/dist/api/base.js

@@ -0,0 +1,115 @@
+/**
+ * HTTP Client for Scribe API
+ * Handles all HTTP communication with the Scribe service
+ */
+import { ScribeError } from '../utils/errors';
+export class HttpClient {
+    constructor(apiKey, debug = false) {
+        this.apiKey = apiKey;
+        this.debug = debug;
+    }
+    /**
+     * Make an HTTP request
+     */
+    async request(url, config) {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            ...config.headers,
+        };
+        // Add API key header if provided
+        if (this.apiKey) {
+            headers['X-API-Key'] = this.apiKey;
+        }
+        const requestInit = {
+            method: config.method,
+            headers,
+            // Include cookies for authentication when API key is not provided
+            credentials: 'include',
+        };
+        if (config.body) {
+            requestInit.body = JSON.stringify(config.body);
+        }
+        if (this.debug) {
+            console.log('[ScribeSDK] Request:', {
+                url,
+                method: config.method,
+                headers,
+                body: config.body,
+            });
+        }
+        try {
+            const response = await fetch(url, requestInit);
+            if (this.debug) {
+                console.log('[ScribeSDK] Response:', {
+                    status: response.status,
+                    statusText: response.statusText,
+                });
+            }
+            // Handle successful responses
+            if (response.ok) {
+                const data = await response.json();
+                return data;
+            }
+            // Handle error responses
+            await this.handleErrorResponse(response);
+            // This line should never be reached, but TypeScript needs it
+            throw new ScribeError('Unexpected error occurred');
+        }
+        catch (error) {
+            if (error instanceof ScribeError) {
+                throw error;
+            }
+            // Network or parsing errors
+            throw new ScribeError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`, 'network_error');
+        }
+    }
+    /**
+     * Handle error responses from the API
+     */
+    async handleErrorResponse(response) {
+        let errorData = null;
+        try {
+            errorData = await response.json();
+        }
+        catch {
+            // If response is not JSON, create a generic error
+            throw new ScribeError(`HTTP ${response.status}: ${response.statusText}`, 'http_error', response.status);
+        }
+        if (errorData?.error) {
+            throw ScribeError.fromApiError(errorData.error, response.status);
+        }
+        // Fallback error
+        throw new ScribeError(`HTTP ${response.status}: ${response.statusText}`, 'http_error', response.status);
+    }
+    /**
+     * GET request
+     */
+    async get(url, headers) {
+        return this.request(url, { method: 'GET', headers });
+    }
+    /**
+     * POST request
+     */
+    async post(url, body, headers) {
+        return this.request(url, { method: 'POST', body, headers });
+    }
+    /**
+     * PUT request
+     */
+    async put(url, body, headers) {
+        return this.request(url, { method: 'PUT', body, headers });
+    }
+    /**
+     * PATCH request
+     */
+    async patch(url, body, headers) {
+        return this.request(url, { method: 'PATCH', body, headers });
+    }
+    /**
+     * DELETE request
+     */
+    async delete(url, headers) {
+        return this.request(url, { method: 'DELETE', headers });
+    }
+}

package/dist/api/discovery.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Discovery API
+ * Implements the Discovery endpoint (Spec 04)
+ */
+import { DiscoveryDocument } from '../types';
+import { HttpClient } from './base';
+export declare class DiscoveryAPI {
+    private httpClient;
+    private cachedDiscovery;
+    private cacheTimestamp;
+    private cacheDuration;
+    constructor(httpClient: HttpClient);
+    /**
+     * Fetch discovery document from the well-known endpoint
+     * Implements caching as recommended in Spec 04.8
+     *
+     * @param baseUrl - The base URL of the Scribe service
+     * @param forceRefresh - Force refresh the cache
+     */
+    getDiscovery(baseUrl: string, forceRefresh?: boolean): Promise<DiscoveryDocument>;
+    /**
+     * Clear the discovery cache
+     */
+    clearCache(): void;
+    /**
+     * Get cached discovery document without making a request
+     */
+    getCachedDiscovery(): DiscoveryDocument | null;
+}
+//# sourceMappingURL=discovery.d.ts.map

package/dist/api/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/api/discovery.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,aAAa,CAAuB;gBAEhC,UAAU,EAAE,UAAU;IAIlC;;;;;;OAMG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAqB9F;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,kBAAkB,IAAI,iBAAiB,GAAG,IAAI;CAO/C"}

package/dist/api/discovery.js

@@ -0,0 +1,52 @@
+/**
+ * Discovery API
+ * Implements the Discovery endpoint (Spec 04)
+ */
+import { WELL_KNOWN_PATH } from '../constants';
+export class DiscoveryAPI {
+    constructor(httpClient) {
+        this.cachedDiscovery = null;
+        this.cacheTimestamp = 0;
+        this.cacheDuration = 3600 * 1000; // 1 hour in milliseconds
+        this.httpClient = httpClient;
+    }
+    /**
+     * Fetch discovery document from the well-known endpoint
+     * Implements caching as recommended in Spec 04.8
+     *
+     * @param baseUrl - The base URL of the Scribe service
+     * @param forceRefresh - Force refresh the cache
+     */
+    async getDiscovery(baseUrl, forceRefresh = false) {
+        const now = Date.now();
+        // Return cached discovery if valid
+        if (!forceRefresh && this.cachedDiscovery && now - this.cacheTimestamp < this.cacheDuration) {
+            return this.cachedDiscovery;
+        }
+        // Construct well-known URL
+        const discoveryUrl = new URL(WELL_KNOWN_PATH, baseUrl).toString();
+        // Fetch discovery document
+        const discovery = await this.httpClient.get(discoveryUrl);
+        // Cache the discovery document
+        this.cachedDiscovery = discovery;
+        this.cacheTimestamp = now;
+        return discovery;
+    }
+    /**
+     * Clear the discovery cache
+     */
+    clearCache() {
+        this.cachedDiscovery = null;
+        this.cacheTimestamp = 0;
+    }
+    /**
+     * Get cached discovery document without making a request
+     */
+    getCachedDiscovery() {
+        const now = Date.now();
+        if (this.cachedDiscovery && now - this.cacheTimestamp < this.cacheDuration) {
+            return this.cachedDiscovery;
+        }
+        return null;
+    }
+}

package/dist/api/session.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Session API
+ * Implements Session Lifecycle endpoints (Spec 06)
+ */
+import { CreateSessionRequest, CreateSessionResponse, EndSessionResponse, GetSessionStatusResponse } from '../types';
+import { HttpClient } from './base';
+export declare class SessionAPI {
+    private httpClient;
+    private baseUrl;
+    constructor(httpClient: HttpClient, baseUrl: string);
+    /**
+     * Update the base URL (e.g., after discovery)
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Create a new session
+     * POST /sessions
+     *
+     * @param request - Session creation parameters
+     * @returns Session creation response with session_id and upload_url
+     */
+    createSession(request: CreateSessionRequest): Promise<CreateSessionResponse>;
+    /**
+     * Get session status
+     * GET /sessions/{sessionId}
+     *
+     * @param sessionId - The session ID
+     * @returns Current session status and results (if available)
+     */
+    getSessionStatus(sessionId: string): Promise<GetSessionStatusResponse>;
+    /**
+     * End a session
+     * POST /sessions/{sessionId}/end
+     *
+     * This triggers processing of the uploaded audio.
+     * No more audio can be uploaded after this call.
+     *
+     * @param sessionId - The session ID
+     * @returns End session response with processing status
+     */
+    endSession(sessionId: string): Promise<EndSessionResponse>;
+    /**
+     * Poll for session completion
+     * Repeatedly checks session status until it's completed, partial, or failed
+     *
+     * @param sessionId - The session ID
+     * @param options - Polling options
+     * @returns Final session status
+     */
+    pollSessionStatus(sessionId: string, options?: {
+        maxAttempts?: number;
+        intervalMs?: number;
+        onProgress?: (status: GetSessionStatusResponse) => void;
+    }): Promise<GetSessionStatusResponse>;
+    /**
+     * Helper function to sleep
+     */
+    private sleep;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/api/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/api/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAGpC,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAS;gBAEZ,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM;IAKnD;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;;;OAMG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAQlF;;;;;;OAMG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAQ5E;;;;;;;;;OASG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAKhE;;;;;;;OAOG;IACG,iBAAiB,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,wBAAwB,KAAK,IAAI,CAAC;KACpD,GACL,OAAO,CAAC,wBAAwB,CAAC;IAiCpC;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}