@eka-care/medassist-core 1.0.0

package/dist/internal/Error/Error.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.ConfigurationError = exports.StoreError = exports.MessageError = exports.SessionError = exports.FileError = exports.RecordingError = exports.ConnectionError = exports.InternalServerError = exports.RateLimitError = exports.MethodNotAllowedError = exports.NotFoundError = exports.PermissionDeniedError = exports.UnauthorizedError = exports.BadRequestError = exports.APIConnectionTimeoutError = exports.APIUserAbortError = exports.APIError = exports.SynapseError = exports.SynapseErrorCode = void 0;
+exports.normalizeError = normalizeError;
+exports.SynapseErrorCode = {
+    API: "API_ERROR",
+    CONNECTION: "CONNECTION_ERROR",
+    RECORDING: "RECORDING_ERROR",
+    FILE: "FILE_ERROR",
+    SESSION: "SESSION_ERROR",
+    MESSAGE: "MESSAGE_ERROR",
+    STORE: "STORE_ERROR",
+    CONFIGURATION: "CONFIGURATION_ERROR",
+    VALIDATION: "VALIDATION_ERROR",
+    AUTH: "AUTH_ERROR",
+    UNKNOWN: "UNKNOWN_ERROR",
+};
+class SynapseError extends Error {
+    code;
+    timestamp;
+    cause;
+    context;
+    hint;
+    constructor(message, code = exports.SynapseErrorCode.UNKNOWN, options = {}) {
+        super(message);
+        this.name = "SynapseError";
+        this.code = code;
+        this.timestamp = new Date();
+        this.cause = options.cause;
+        this.context = options.context;
+        this.hint = options.hint;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.SynapseError = SynapseError;
+class APIError extends SynapseError {
+    /** HTTP status code */
+    status;
+    /** JSON body of the error response or custom error object */
+    error;
+    /** HTTP response headers */
+    headers;
+    constructor(message, status, error, headers) {
+        const errorMessage = APIError.makeMessage(status, error, message);
+        super(errorMessage, exports.SynapseErrorCode.API, {
+            cause: error,
+            context: {
+                status,
+                hasBody: Boolean(error),
+            },
+            hint: status && status >= 500
+                ? "Retry the request or contact support if the issue persists."
+                : undefined,
+        });
+        this.name = "APIError";
+        this.status = status;
+        this.error = error;
+        this.headers = headers;
+    }
+    static makeMessage(status, error, message) {
+        const msg = error instanceof Error ? error.message : message;
+        if (status && msg) {
+            return `HTTP ${status}: ${msg}`;
+        }
+        if (status) {
+            return `${status} status code (no body)`;
+        }
+        if (msg) {
+            return msg;
+        }
+        return "(no status code or body)";
+    }
+    static generate(status, errorResponse, message, headers) {
+        if (!status) {
+            return new APIUserAbortError({ message });
+        }
+        const extractedError = errorResponse?.["error"];
+        const error = extractedError &&
+            typeof extractedError === "object" &&
+            !Array.isArray(extractedError)
+            ? extractedError
+            : undefined;
+        switch (status) {
+            case 400:
+                return new BadRequestError(message || "Bad Request", status, error, headers);
+            case 401:
+                return new UnauthorizedError(message || "Unauthorized", status, error, headers);
+            case 403:
+                return new PermissionDeniedError(message || "Permission Denied", status, error, headers);
+            case 404:
+                return new NotFoundError(message || "Not Found", status, error, headers);
+            case 405:
+                return new MethodNotAllowedError(message || "Method Not Allowed", status, error, headers);
+            case 429:
+                return new RateLimitError(message || "Rate Limit Exceeded", status, error, headers);
+            case 500:
+                return new InternalServerError(message || "Internal Server Error", status, error, headers);
+            default:
+                return new APIError(message || "API Error", status, error, headers);
+        }
+    }
+}
+exports.APIError = APIError;
+class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+        super(message || "Request was aborted.", undefined, undefined, undefined);
+        this.name = "APIUserAbortError";
+    }
+}
+exports.APIUserAbortError = APIUserAbortError;
+class APIConnectionTimeoutError extends APIError {
+    constructor({ message } = {}) {
+        super(message || "Request timed out.", undefined, undefined, undefined);
+        this.name = "APIConnectionTimeoutError";
+    }
+}
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+class BadRequestError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "BadRequestError";
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnauthorizedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "UnauthorizedError";
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class PermissionDeniedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "PermissionDeniedError";
+    }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class NotFoundError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class MethodNotAllowedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "MethodNotAllowedError";
+    }
+}
+exports.MethodNotAllowedError = MethodNotAllowedError;
+class RateLimitError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
+class InternalServerError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "InternalServerError";
+    }
+}
+exports.InternalServerError = InternalServerError;
+class ConnectionError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.CONNECTION, options);
+        this.name = "ConnectionError";
+    }
+}
+exports.ConnectionError = ConnectionError;
+class RecordingError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.RECORDING, options);
+        this.name = "RecordingError";
+    }
+}
+exports.RecordingError = RecordingError;
+class FileError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.FILE, options);
+        this.name = "FileError";
+    }
+}
+exports.FileError = FileError;
+class SessionError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.SESSION, options);
+        this.name = "SessionError";
+    }
+}
+exports.SessionError = SessionError;
+class MessageError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.MESSAGE, options);
+        this.name = "MessageError";
+    }
+}
+exports.MessageError = MessageError;
+class StoreError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.STORE, options);
+        this.name = "StoreError";
+    }
+}
+exports.StoreError = StoreError;
+class ConfigurationError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.CONFIGURATION, options);
+        this.name = "ConfigurationError";
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+class ValidationError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, exports.SynapseErrorCode.VALIDATION, options);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+function normalizeError(error, ctor, fallbackMessage, options = {}) {
+    if (error instanceof ctor) {
+        return error;
+    }
+    const baseOptions = {
+        ...options,
+        context: {
+            ...(error instanceof SynapseError ? error.context : undefined),
+            ...options.context,
+        },
+        hint: options.hint ?? (error instanceof SynapseError ? error.hint : undefined),
+        cause: options.cause ?? error,
+    };
+    if (error instanceof SynapseError) {
+        return new ctor(error.message, baseOptions);
+    }
+    const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+    return new ctor(message, baseOptions);
+}

package/dist/internal/Error/types.d.ts

@@ -0,0 +1,17 @@
+export declare const ErrorType: {
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly API_ERROR: "API_ERROR";
+    readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+export type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+export interface ErrorContext {
+    operation: string;
+    agentId: string;
+    sessionId: string;
+    timestamp: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/internal/Error/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/internal/Error/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;CAQZ,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/internal/Error/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorType = void 0;
+exports.ErrorType = {
+    NETWORK_ERROR: "NETWORK_ERROR",
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    API_ERROR: "API_ERROR",
+    RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR",
+    SERVER_ERROR: "SERVER_ERROR",
+    PARSE_ERROR: "PARSE_ERROR",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR",
+};

package/dist/internal/connection/BaseConnection.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Abstract base class for all connection types
+ */
+import { type IncomingMessage, type OutgoingMessage } from "../../messages/types";
+import { ConnectionStatus, type DisconnectionDetails, type OnDisconnectCallback, type OnMessageCallback, type OnStatusChangeCallback, type OnOpenCallback, type OnErrorCallback } from "./types";
+export declare abstract class BaseConnection {
+    /**
+     * Unique identifier for the current conversation
+     */
+    abstract readonly conversationId: string;
+    /**
+     * Current connection status
+     */
+    protected status: ConnectionStatus;
+    /**
+     * Queue to store messages received before callback is registered
+     */
+    protected queue: IncomingMessage[];
+    /**
+     * Event emitter to handle events
+     */
+    private eventEmitter;
+    /**
+     * Disconnection details (null if still connected)
+     */
+    protected disconnectionDetails: DisconnectionDetails | null;
+    protected onErrorCallback: OnErrorCallback | null;
+    protected onDisconnectCallback: OnDisconnectCallback | null;
+    protected onMessageCallback: OnMessageCallback | null;
+    protected onOpenCallback: OnOpenCallback | null;
+    protected onStatusChangeCallback: OnStatusChangeCallback | null;
+    /**
+     * Close the connection
+     */
+    abstract close(): void;
+    /**
+     * Send a message through the connection
+     */
+    abstract sendMessage(message: OutgoingMessage): void;
+    /**
+     * Get current connection status
+     */
+    getStatus(): ConnectionStatus;
+    /**
+     * Register callback for connection open events
+     */
+    onOpen(callback: OnOpenCallback): void;
+    /**
+     * Register callback for incoming messages
+     */
+    onMessage(callback: OnMessageCallback): void;
+    /**
+     * Register callback for disconnection events
+     */
+    onDisconnect(callback: OnDisconnectCallback): void;
+    /**
+     * Register callback for error events
+     */
+    onError(callback: OnErrorCallback): void;
+    /**
+     * Register a listener for a specific event
+     */
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event: string, listener: (...args: unknown[]) => void): void;
+    /**
+     * Emit an event
+     */
+    emit(event: string, ...args: unknown[]): void;
+    /**
+     * Register callback for status changes
+     */
+    onStatusChange(callback: OnStatusChangeCallback): void;
+    /**
+     * Protected method to handle disconnection
+     * Ensures disconnect callback is only invoked once
+     */
+    protected disconnect(details: DisconnectionDetails): void;
+    /**
+     * Protected method to handle incoming messages
+     * Queues messages if no callback is registered yet
+     * message type can be extended to include more types of messages
+     */
+    protected handleMessage(message: IncomingMessage): void;
+    /**
+     * Protected method to update connection status
+     */
+    protected updateStatus(status: ConnectionStatus): void;
+    /**
+     * Check if the connection is connected
+     */
+    abstract isConnected(): boolean;
+    /**
+     * handle connection established event
+     */
+    abstract handleConnected(): void;
+}
+//# sourceMappingURL=BaseConnection.d.ts.map

package/dist/internal/connection/BaseConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConnection.d.ts","sourceRoot":"","sources":["../../../src/internal/connection/BaseConnection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAElF,OAAO,EACL,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EAEtB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,SAAS,CAAC;AAEjB,8BAAsB,cAAc;IAClC;;OAEG;IACH,kBAAyB,cAAc,EAAE,MAAM,CAAC;IAEhD;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,gBAAgB,CAA+B;IAEjE;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,CAAM;IAExC;;OAEG;IACH,OAAO,CAAC,YAAY,CAAoC;IACxD;;OAEG;IACH,SAAS,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACnE,SAAS,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAQ;IACzD,SAAS,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACnE,SAAS,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAQ;IAC7D,SAAS,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAQ;IACvD,SAAS,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,IAAI,CAAQ;IACvE;;OAEG;aACa,KAAK,IAAI,IAAI;IAE7B;;OAEG;aACa,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAE3D;;OAEG;IACI,SAAS,IAAI,gBAAgB;IAIpC;;OAEG;IACI,MAAM,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAI7C;;OAEG;IACI,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAYnD;;OAEG;IACI,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IASzD;;OAEG;IACI,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAG/C;;OAEG;IACI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI;IAItE;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI;IAIvE;;OAEG;IACI,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAIpD;;OAEG;IACI,cAAc,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAS7D;;;OAGG;IACH,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAQzD;;;;OAIG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAQvD;;OAEG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAOtD;;OAEG;aACa,WAAW,IAAI,OAAO;IACtC;;OAEG;aACa,eAAe,IAAI,IAAI;CACxC"}

package/dist/internal/connection/BaseConnection.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Abstract base class for all connection types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseConnection = void 0;
+const EventEmitter_1 = require("../events/EventEmitter");
+const types_1 = require("./types");
+class BaseConnection {
+    /**
+     * Current connection status
+     */
+    status = types_1.ConnectionStatus.CONNECTING;
+    /**
+     * Queue to store messages received before callback is registered
+     */
+    queue = [];
+    /**
+     * Event emitter to handle events
+     */
+    eventEmitter = new EventEmitter_1.EventEmitter();
+    /**
+     * Disconnection details (null if still connected)
+     */
+    disconnectionDetails = null;
+    onErrorCallback = null;
+    onDisconnectCallback = null;
+    onMessageCallback = null;
+    onOpenCallback = null;
+    onStatusChangeCallback = null;
+    /**
+     * Get current connection status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Register callback for connection open events
+     */
+    onOpen(callback) {
+        this.onOpenCallback = callback;
+    }
+    /**
+     * Register callback for incoming messages
+     */
+    onMessage(callback) {
+        this.onMessageCallback = callback;
+        if (this.queue.length > 0) {
+            const pendingMessages = [...this.queue];
+            this.queue.length = 0;
+            queueMicrotask(() => {
+                pendingMessages.forEach((message) => {
+                    this.onMessageCallback?.(message);
+                });
+            });
+        }
+    }
+    /**
+     * Register callback for disconnection events
+     */
+    onDisconnect(callback) {
+        this.onDisconnectCallback = callback;
+        const details = this.disconnectionDetails;
+        if (details) {
+            queueMicrotask(() => {
+                this.onDisconnectCallback?.(details);
+            });
+        }
+    }
+    /**
+     * Register callback for error events
+     */
+    onError(callback) {
+        this.onErrorCallback = callback;
+    }
+    /**
+     * Register a listener for a specific event
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, ...args) {
+        this.eventEmitter.emit(event, ...args);
+    }
+    /**
+     * Register callback for status changes
+     */
+    onStatusChange(callback) {
+        this.onStatusChangeCallback = callback;
+        // Immediately invoke with current status
+        queueMicrotask(() => {
+            callback(this.status);
+        });
+    }
+    /**
+     * Protected method to handle disconnection
+     * Ensures disconnect callback is only invoked once
+     */
+    disconnect(details) {
+        if (!this.disconnectionDetails) {
+            this.disconnectionDetails = details;
+            this.updateStatus(types_1.ConnectionStatus.NOT_CONNECTED);
+            this.onDisconnectCallback?.(details);
+        }
+    }
+    /**
+     * Protected method to handle incoming messages
+     * Queues messages if no callback is registered yet
+     * message type can be extended to include more types of messages
+     */
+    handleMessage(message) {
+        if (this.onMessageCallback) {
+            this.onMessageCallback(message);
+        }
+        else {
+            this.queue.push(message);
+        }
+    }
+    /**
+     * Protected method to update connection status
+     */
+    updateStatus(status) {
+        if (this.status !== status) {
+            this.status = status;
+            this.onStatusChangeCallback?.(status);
+        }
+    }
+}
+exports.BaseConnection = BaseConnection;

package/dist/internal/connection/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Connection types and interfaces for the Synapse SDK
+ */
+import { type IncomingMessage } from "../../messages/types";
+export declare const ConnectionStatus: {
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly NOT_CONNECTED: "not_connected";
+};
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+export declare const DisconnectionReason: {
+    readonly CLIENT_CLOSED: "client_closed";
+    readonly SERVER_CLOSED: "server_closed";
+    readonly CONNECTION_ERROR: "connection_error";
+    readonly AUTHENTICATION_ERROR: "authentication_error";
+    readonly MAX_RECONNECT_ATTEMPTS: "max_reconnect_attempts";
+    readonly TIMEOUT: "timeout";
+    readonly NETWORK_ERROR: "network_error";
+};
+export type DisconnectionReason = (typeof DisconnectionReason)[keyof typeof DisconnectionReason];
+export interface DisconnectionDetails {
+    reason: DisconnectionReason;
+    message?: string;
+    code?: number;
+    timestamp: Date;
+}
+export interface SessionConfig {
+    agentId: string;
+    authorization?: string;
+    overrides?: {
+        prompt?: string;
+        firstMessage?: string;
+        language?: string;
+        voiceId?: string;
+    };
+    userId?: string;
+}
+export type OnDisconnectCallback = (details: DisconnectionDetails) => void;
+export type OnMessageCallback = (event: IncomingMessage) => void;
+export type OnStatusChangeCallback = (status: ConnectionStatus) => void;
+export type OnOpenCallback = () => void;
+export type OnErrorCallback = (error: Error) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/internal/connection/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/internal/connection/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,mBAAmB;;;;;;;;CAQtB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEjE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;CACjB;AAeD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE;QACV,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AACjE,MAAM,MAAM,sBAAsB,GAAG,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC;AACxC,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC"}

package/dist/internal/connection/types.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Connection types and interfaces for the Synapse SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisconnectionReason = exports.ConnectionStatus = void 0;
+exports.ConnectionStatus = {
+    CONNECTING: "connecting",
+    CONNECTED: "connected",
+    NOT_CONNECTED: "not_connected",
+};
+exports.DisconnectionReason = {
+    CLIENT_CLOSED: "client_closed",
+    SERVER_CLOSED: "server_closed",
+    CONNECTION_ERROR: "connection_error",
+    AUTHENTICATION_ERROR: "authentication_error",
+    MAX_RECONNECT_ATTEMPTS: "max_reconnect_attempts",
+    TIMEOUT: "timeout",
+    NETWORK_ERROR: "network_error",
+};

package/dist/internal/events/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export declare class EventEmitter {
+    private eventListeners;
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    off(event: string, listener: (...args: unknown[]) => void): void;
+    emit(event: string, ...args: unknown[]): void;
+}
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/internal/events/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../../src/internal/events/EventEmitter.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc,CACV;IAEL,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI;IAM/D,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI;IAUhE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAMrD"}

package/dist/internal/events/EventEmitter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+class EventEmitter {
+    eventListeners = new Map();
+    on(event, listener) {
+        const listeners = this.eventListeners.get(event) || new Set();
+        listeners.add(listener);
+        this.eventListeners.set(event, listeners);
+    }
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.eventListeners.delete(event);
+            }
+        }
+    }
+    emit(event, ...args) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach((listener) => listener(...args));
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;

package/dist/internal/store/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * make an abstract class for all types of storage (localStorage, sessionStorage, etc.)
+ */
+export declare abstract class Storage {
+    abstract write(key: string): string | null;
+    abstract read(key: string): string | null;
+    abstract delete(key: string): void;
+    abstract clear(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/internal/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/internal/store/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,8BAAsB,OAAO;IAC3B,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAC1C,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IACzC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAClC,QAAQ,CAAC,KAAK,IAAI,IAAI;CACvB"}

package/dist/internal/store/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * make an abstract class for all types of storage (localStorage, sessionStorage, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+class Storage {
+}
+exports.Storage = Storage;