@eka-care/medassist-core 1.0.70 → 1.0.71

package/dist/index.d.mts

@@ -0,0 +1,1442 @@
+/**
+ * Types for agent configuration initialization
+ */
+interface AgentConfig {
+    agentId: string;
+    name: string;
+    prompt: string;
+    firstMessage: string;
+    language: string;
+    theme?: {
+        primaryColor?: string;
+        backgroundColor?: string;
+        fontFamily?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface ResourceConfig {
+    agentId: string;
+    serverUrl: string;
+    authorization?: string;
+    authToken?: string;
+}
+type ResourceResponse = {
+    error?: {
+        code: string;
+        msg: string;
+    };
+};
+
+type TDoctorToolResponse = ResourceResponse & TDoctorDetails;
+type TAvailabilitySlotsToolResponse = ResourceResponse & {
+    slots: string[];
+};
+type TAvailabilityDatesToolResponse = ResourceResponse & {
+    available_dates: string[];
+};
+declare enum SYNAPSE_TOOL_NAME {
+    MOBILE_VERIFICATION = "mobile_verification",
+    AVAILABILITY_DATES = "availability_dates",
+    AVAILABILITY_SLOTS = "availability_slots",
+    DOCTOR_AVAILABILITY = "doctor_availability",
+    DOCTOR_DETAILS = "doctor_details",
+    GET_LOCATION = "get_location"
+}
+declare enum SYNAPSE_COMPONENTS {
+    MOBILE = "mobile_number",
+    OTP = "otp",
+    EMAIL = "email_address",
+    PILL = "pills",
+    MULTI = "multi",
+    DOCTOR_CARD = "doctor_card",
+    CARD = "card",
+    MEDIA_CARD = "media_card"
+}
+type SYNAPSE_TOOL_TYPES = {
+    ELICITATION: "elicitation";
+};
+type TDoctorDetailsMap = {
+    [doctor_id: string]: TDoctorDetails;
+};
+type ToolCallbacks = {
+    [key in SYNAPSE_TOOL_CALLBACK_NAME]: {
+        tool_name: SYNAPSE_TOOL_NAME;
+        input_schema: Record<string, unknown>;
+    };
+};
+declare enum SYNAPSE_TOOL_CALLBACK_NAME {
+    DOCTOR_AVAILABILITY = "get_doctor_availability",
+    AVAILABILITY_DATES = "get_available_dates",
+    AVAILABILITY_SLOTS = "get_available_slots",
+    MOBILE_VERIFICATION = "verify_mobile_number",
+    DOCTOR_DETAILS = "get_doctor_details"
+}
+type TGetLocationToolResponse = ResourceResponse & {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+};
+type TDoctorCardInput = {
+    doctors: TDoctorAvailability[];
+    doctor_details?: TDoctorDetailsMap;
+};
+type TOption = {
+    id: string;
+    label: string;
+    value: string;
+};
+type SynapseInputCompMap = {
+    [SYNAPSE_COMPONENTS.CARD]: {
+        cards: TCardInput[];
+    };
+    [SYNAPSE_COMPONENTS.DOCTOR_CARD]: TDoctorCardInput;
+    [SYNAPSE_COMPONENTS.MEDIA_CARD]: {
+        media_card: TMediaCard;
+    };
+    [SYNAPSE_COMPONENTS.MULTI]: {
+        options: TOption[];
+    };
+    [SYNAPSE_COMPONENTS.PILL]: {
+        options: TOption[];
+    };
+    [SYNAPSE_COMPONENTS.OTP]: {
+        otp?: string;
+    };
+    [SYNAPSE_COMPONENTS.MOBILE]: {
+        mobile_number?: string;
+    };
+    [SYNAPSE_COMPONENTS.EMAIL]: {
+        email_address?: string;
+    };
+};
+type SynapseSelectedCompMap = {
+    [SYNAPSE_COMPONENTS.CARD]: TCardInput;
+    [SYNAPSE_COMPONENTS.DOCTOR_CARD]: TDoctorAvailability;
+    [SYNAPSE_COMPONENTS.MEDIA_CARD]: TMediaCard;
+    [SYNAPSE_COMPONENTS.MULTI]: TOption;
+    [SYNAPSE_COMPONENTS.PILL]: TOption;
+    [SYNAPSE_COMPONENTS.EMAIL]: {
+        email_address?: string;
+    };
+    [SYNAPSE_COMPONENTS.OTP]: {
+        otp?: string;
+    };
+    [SYNAPSE_COMPONENTS.MOBILE]: {
+        mobile_number?: string;
+    };
+};
+type ToolInputTypes = SynapseSelectedCompMap[keyof SynapseSelectedCompMap];
+type BaseToolDetails = {
+    status?: SYNAPSE_EICITATION_STATUS;
+    _meta?: {
+        schema?: {
+            type: "object";
+            properties?: {
+                [key: string]: {
+                    type?: string | number | object;
+                    description?: string;
+                    pattern?: string;
+                    minLength?: number;
+                    maxLength?: number;
+                    example?: string;
+                };
+            };
+            required?: string[];
+        };
+        tool_result?: Record<string, unknown>;
+        disp_message?: string;
+        hidden_message?: string;
+        toast_message?: string;
+        mcp_meta_fields?: string[];
+        disp_toast_msg?: string;
+        orientation?: "vertical" | "horizontal";
+        user_hint?: string;
+    };
+};
+type ComponentToolDetails<C extends SYNAPSE_COMPONENTS> = BaseToolDetails & {
+    component: C;
+    input: SynapseInputCompMap[C] & {
+        text?: string;
+    };
+};
+type ToolDetails = {
+    [C in SYNAPSE_COMPONENTS]: ComponentToolDetails<C>;
+}[SYNAPSE_COMPONENTS];
+declare enum SYNAPSE_EICITATION_STATUS {
+    PROGRESS = "progress",
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+type ToolCallResponse = StreamMatrixToSynapseMessage & ResourceResponse;
+
+/**
+ * Event types for message layer
+ * These are specific to the messaging layer and don't affect the base connection layer
+ */
+
+interface BaseMessage {
+    ev: SOCKET_EVENTS;
+    _id: string;
+    ts: number;
+}
+interface PingMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["PING"];
+}
+interface PongMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["PONG"];
+}
+interface ErrorMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["ERROR"];
+    data: {
+        code: string;
+        msg: string;
+        socket_code?: number;
+    };
+}
+interface SyncMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["SYNC"];
+}
+interface AuthSynapseToMatrixMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["AUTH"];
+    data: {
+        token: string;
+    };
+}
+interface ChatSynapseToMatrixMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["CHAT"];
+    ct: (typeof SOCKET_CONTENT_TYPES)["TEXT"] | (typeof SOCKET_CONTENT_TYPES)["FILE"] | (typeof SOCKET_CONTENT_TYPES)["TOOL_CALL"] | (typeof SOCKET_CONTENT_TYPES)["AUDIO"];
+    data?: {
+        urls?: string[];
+        text?: string;
+        tool_id?: string;
+        hidden?: boolean;
+        extensions?: string[];
+        tool_result?: Record<string, unknown>;
+        audio?: string;
+        format?: string;
+    };
+}
+interface StreamSynapseToMatrixMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["STREAM"];
+    ct: (typeof SOCKET_CONTENT_TYPES)["AUDIO"];
+    data: {
+        audio: string;
+        format: string;
+    };
+}
+interface EndOfStreamSynapseToMatrixMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["END_OF_STREAM"];
+}
+interface ConnectionEstablishedMatrixToSynapseMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["CONNECTION_ESTABLISHED"];
+    sid: string;
+    msg: string;
+}
+type ToolCallData = {
+    tool_id: string | null;
+    tool_type?: SYNAPSE_TOOL_TYPES;
+    tool_name: string;
+    details?: ToolDetails;
+    meta?: Record<string, unknown>;
+};
+interface presignedUrls {
+    id: string;
+    url: string;
+}
+interface ChatMatrixToSynapseMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["CHAT"];
+    ct: Exclude<SOCKET_CONTENT_TYPES, (typeof SOCKET_CONTENT_TYPES)["AUDIO"]>;
+    data: {
+        urls?: presignedUrls[];
+        exp?: number;
+        text?: string;
+        tips?: string[];
+    } & Partial<ToolCallData>;
+}
+interface StreamMatrixToSynapseMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["STREAM"];
+    ct: (typeof SOCKET_CONTENT_TYPES)["TEXT"] | (typeof SOCKET_CONTENT_TYPES)["TIPS"] | (typeof SOCKET_CONTENT_TYPES)["TOOL_CALL"] | (typeof SOCKET_CONTENT_TYPES)["TOOL_START"] | (typeof SOCKET_CONTENT_TYPES)["TOOL_END"];
+    data: {
+        text?: string;
+        progress_msg?: string;
+        tips?: string[];
+    } & Partial<ToolCallData>;
+}
+interface EndOfStreamMatrixToSynapseMessage extends BaseMessage {
+    ev: (typeof SOCKET_EVENTS)["END_OF_STREAM"];
+    ct: (typeof SOCKET_CONTENT_TYPES)["TEXT"];
+}
+
+type OutgoingSocketMessage = PingMessage | PongMessage | ErrorMessage | SyncMessage | AuthSynapseToMatrixMessage | ChatSynapseToMatrixMessage | StreamSynapseToMatrixMessage | EndOfStreamSynapseToMatrixMessage;
+type IncomingSocketMessage = PingMessage | PongMessage | ErrorMessage | SyncMessage | ConnectionEstablishedMatrixToSynapseMessage | ChatMatrixToSynapseMessage | StreamMatrixToSynapseMessage | EndOfStreamMatrixToSynapseMessage;
+declare const SOCKET_CONTENT_TYPES: {
+    readonly TEXT: "text";
+    readonly AUDIO: "audio";
+    readonly FILE: "file";
+    readonly TOOL_CALL: "tool";
+    readonly TIPS: "tips";
+    readonly AUDIO_TRANSCRIPT: "audio_transcript";
+    readonly TOOL_START: "tool_start";
+    readonly TOOL_END: "tool_end";
+};
+type SOCKET_CONTENT_TYPES = (typeof SOCKET_CONTENT_TYPES)[keyof typeof SOCKET_CONTENT_TYPES];
+declare const SOCKET_EVENTS: {
+    readonly PING: "ping";
+    readonly PONG: "pong";
+    readonly CHAT: "chat";
+    readonly STREAM: "stream";
+    readonly AUTH: "auth";
+    readonly END_OF_STREAM: "eos";
+    readonly SYNC: "sync";
+    readonly ERROR: "err";
+    readonly CONNECTION_ESTABLISHED: "conn";
+};
+type SOCKET_EVENTS = (typeof SOCKET_EVENTS)[keyof typeof SOCKET_EVENTS];
+type IncomingSocketErrorMessage = ErrorMessage;
+type IncomingSocketChatMessage = ChatMatrixToSynapseMessage;
+type IncomingSocketStreamMessage = StreamMatrixToSynapseMessage;
+type IncomingSocketEndOfStreamMessage = EndOfStreamMatrixToSynapseMessage;
+
+declare const SynapseErrorCode: {
+    readonly API: "API_ERROR";
+    readonly CONNECTION: "CONNECTION_ERROR";
+    readonly RECORDING: "RECORDING_ERROR";
+    readonly FILE: "FILE_ERROR";
+    readonly SESSION: "SESSION_ERROR";
+    readonly MESSAGE: "MESSAGE_ERROR";
+    readonly STORE: "STORE_ERROR";
+    readonly CONFIGURATION: "CONFIGURATION_ERROR";
+    readonly VALIDATION: "VALIDATION_ERROR";
+    readonly AUTH: "AUTH_ERROR";
+    readonly UNKNOWN: "UNKNOWN_ERROR";
+};
+type SynapseErrorCode = (typeof SynapseErrorCode)[keyof typeof SynapseErrorCode];
+interface SynapseErrorOptions {
+    cause?: unknown;
+    displayMessage?: string;
+    context?: Record<string, unknown>;
+    hint?: string;
+}
+declare class SynapseError extends Error {
+    readonly code: SynapseErrorCode;
+    readonly timestamp: Date;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+    readonly hint?: string;
+    readonly displayMessage?: string;
+    constructor(message: string, code?: SynapseErrorCode, options?: SynapseErrorOptions);
+}
+declare class APIError<TStatus extends number | undefined = number | undefined, THeader extends Headers | undefined = Headers | undefined, TError extends Record<string, unknown> | undefined = Record<string, unknown> | undefined> extends SynapseError {
+    /** HTTP status code */
+    readonly status?: TStatus;
+    /** JSON body of the error response or custom error object */
+    readonly error?: TError;
+    /** HTTP response headers */
+    readonly headers?: THeader;
+    constructor(message: string, status?: TStatus, error?: TError, headers?: THeader);
+    private static makeMessage;
+    static generate(status: number | undefined, errorResponse: Record<string, unknown> | undefined, message?: string, headers?: Headers): APIError<number, Headers, Record<string, unknown>>;
+}
+declare class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+    constructor({ message }?: {
+        message?: string;
+    });
+}
+declare class APIConnectionTimeoutError extends APIError<undefined, undefined, undefined> {
+    constructor({ message }?: {
+        message?: string;
+    });
+}
+declare class BadRequestError extends APIError<400, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 400, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class UnauthorizedError extends APIError<401, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 401, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class PermissionDeniedError extends APIError<403, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 403, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class NotFoundError extends APIError<404, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 404, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class MethodNotAllowedError extends APIError<405, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 405, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class RateLimitError extends APIError<429, Headers, Record<string, unknown>> {
+    constructor(message: string, status: 429, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class InternalServerError extends APIError<number, Headers, Record<string, unknown>> {
+    constructor(message: string, status: number, error?: Record<string, unknown>, headers?: Headers);
+}
+declare class RecordingError extends SynapseError {
+    constructor(message: string, options?: SynapseErrorOptions);
+}
+
+interface AudioMetaData {
+    audio: string;
+    format: string;
+    duration: number;
+    timestamp: number;
+}
+interface AudioConfig {
+    mimeType: string;
+    audioBitsPerSecond: number;
+    maxRecordingDuration: number;
+    autoPauseEnabled: boolean;
+}
+type AudioDataCallback = (data: AudioMetaData) => void;
+type AudioErrorCallback = (error: RecordingError) => void;
+
+/**
+ * Types for message management
+ */
+
+declare const SYNAPSE_MESSAGE_TYPES: {
+    readonly TEXT: "text";
+    readonly AUDIO: "audio";
+    readonly FILE: "file";
+    readonly TOOL_CALL: "tool";
+    readonly TIPS: "tips";
+    readonly AUDIO_TRANSCRIPT: "audio_transcript";
+    readonly TOOL_START: "tool_start";
+    readonly TOOL_END: "tool_end";
+};
+type ContentType = SOCKET_CONTENT_TYPES;
+type IncomingMessage = IncomingSocketMessage;
+type OutgoingMessage = OutgoingSocketMessage;
+interface SocketChatRequestData {
+    message?: string;
+    messageId?: string;
+    files?: File[];
+    audio?: AudioMetaData;
+    urls?: string[];
+    tool_id?: string;
+    tool_declined?: boolean;
+    hidden?: boolean;
+    tool_result?: Record<string, unknown>;
+    initial_prompts?: TInitalPrompt[];
+}
+type TInitalPrompt = {
+    role: string;
+    text: string;
+};
+declare const SYNAPSE_REALTIME_EVENTS: {
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly PROGRESS_MESSAGE: "progress_message";
+    readonly MESSAGE_CHUNK: "message_chunk";
+    readonly TIPS_MESSAGE: "tips_message";
+    readonly END_OF_STREAM: "end_of_stream";
+    readonly ERROR: "error";
+    readonly TOOL_CALL: "tool_call";
+    readonly AUDIO_TRANSCRIPT: "audio_transcript";
+    readonly TOOL_START: "tool_start";
+    readonly TOOL_END: "tool_end";
+};
+type SYNAPSE_REALTIME_EVENTS = (typeof SYNAPSE_REALTIME_EVENTS)[keyof typeof SYNAPSE_REALTIME_EVENTS];
+declare const SYNAPSE_REALTIME_ERROR_CODES: {
+    readonly SESSION_INACTIVE: "session_not_found";
+    readonly SESSION_EXPIRED: "session_expired";
+    readonly INVALID_EVENT: "invalid_event";
+    readonly INVALID_CONTENT_TYPE: "invalid_content";
+    readonly PARSING_ERROR: "parsing";
+    readonly FILE_UPLOAD_INPROGRESS: "file_upload_inprogress";
+    readonly TIMEOUT: "timeout";
+    readonly SERVER_ERROR: "server_error";
+    readonly SESSION_TOKEN_MISMATCH: "session_token_mismatch";
+    readonly PROMPT_FETCH_ERROR: "prompt_fetch_error";
+    readonly INVALID_FILE_REQUEST: "invalid_file_request";
+};
+type SYNAPSE_REALTIME_ERROR_CODES = (typeof SYNAPSE_REALTIME_ERROR_CODES)[keyof typeof SYNAPSE_REALTIME_ERROR_CODES];
+declare const SYNAPSE_REALTIME_RESERVED_EVENTS: {
+    readonly SESSION_EXPIRED: "session_expired";
+};
+type SYNAPSE_REALTIME_RESERVED_EVENTS = (typeof SYNAPSE_REALTIME_RESERVED_EVENTS)[keyof typeof SYNAPSE_REALTIME_RESERVED_EVENTS];
+type SOCKET_STREAM_DATA = AudioMetaData;
+type SynapseRealTimeEventData = {
+    data: {
+        text?: string;
+        tips?: string[];
+        name?: string;
+    } & Partial<ToolCallData>;
+    messageId?: string;
+    timestamp?: number;
+};
+type TDoctorAvailability = {
+    hospital_id?: string;
+    doctor_id?: string;
+    preferred_date?: string;
+    preferred_slot_time?: string;
+    availability?: TAvailability[];
+    date_preference?: string;
+    slot_preference?: string;
+    cta?: TCardCta;
+};
+type TAvailability = {
+    date?: string;
+    day?: string;
+    slots?: string[];
+    selected_slot?: string;
+};
+type THospital = {
+    hospital_id: string;
+    name?: string;
+    city?: string;
+    state?: string;
+    region_id?: string;
+};
+type TDoctorDetails = {
+    name: string;
+    specialty: string;
+    hospitals: THospital[];
+    timings?: string;
+    experience?: string;
+    profile_link?: string;
+    profile_pic?: string;
+    languages?: string;
+    info?: string;
+};
+type TCardInput = {
+    card_id: string;
+    title?: string;
+    tags?: string;
+    icon?: string;
+    description?: string;
+    banner?: {
+        text: string;
+        theme: string;
+    };
+    banner_text?: string;
+    img?: string;
+    items?: TCardItem[];
+    primary_cta?: TCardCta;
+    secondary_cta?: TCardCta;
+};
+type TCardItem = {
+    icon?: string;
+    text: string;
+};
+type TCardCta = {
+    cta_id: string;
+    title: string;
+    link?: string;
+    action?: string;
+    icon?: string;
+    text?: string;
+    tool_result?: Record<string, unknown>;
+};
+type TCardTheme = "success" | "warning" | "danger" | "primary";
+type TMediaCard = {
+    title?: string;
+    description?: string;
+    tags?: string;
+    tags_text?: string;
+    banner_text?: string;
+    action?: "download" | "screenshot";
+    link?: string;
+};
+type SynapseContentTypes = SOCKET_CONTENT_TYPES;
+
+type TInitialMessage = {
+    text?: string;
+    suggestions?: {
+        label?: string;
+        value?: string;
+        response?: string;
+    }[];
+};
+interface SessionResponse extends ResourceResponse {
+    session_id: string;
+    session_token?: string;
+    session_validity_s?: string;
+    user_id?: string;
+    msg?: string;
+    initial_message?: TInitialMessage;
+}
+interface AgentConfigResponse extends ResourceResponse {
+    connectivity?: "sse" | "socket";
+    theme?: {
+        background?: string;
+        background_img?: string;
+        accent?: string;
+        mode?: "light" | "dark";
+        title_img?: string;
+        title?: string;
+        tagline?: string;
+    };
+    initial_message?: TInitialMessage;
+    hide_watermark?: boolean;
+}
+interface SessionCreateRequest {
+    user_id?: string;
+    user_context?: TProfile;
+    session_context?: {
+        intent?: string;
+        user_location?: {
+            lat: number;
+            long: number;
+        };
+        [key: string]: unknown;
+    };
+    referer?: string;
+}
+type TProfile = {
+    mobile?: string;
+    name?: string;
+    age?: number;
+    gender?: "F" | "M" | "O";
+    marital_status?: string;
+    [key: string]: unknown;
+};
+type TContext = {
+    profile?: TProfile;
+    intent?: string;
+    user_location?: {
+        lat: number;
+        long: number;
+    };
+    referer?: string;
+    [key: string]: unknown;
+};
+declare const USER_FEEDBACK: {
+    readonly LIKE: "LIKE";
+    readonly DISLIKE: "DISLIKE";
+    readonly NONE: "NONE";
+};
+type USER_FEEDBACK = (typeof USER_FEEDBACK)[keyof typeof USER_FEEDBACK];
+
+type Environment$1 = "development" | "production" | "staging";
+
+/**
+ * Connection types and interfaces for the Synapse SDK
+ */
+
+declare const ConnectionStatus: {
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly NOT_CONNECTED: "not_connected";
+};
+type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+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";
+};
+type DisconnectionReason = (typeof DisconnectionReason)[keyof typeof DisconnectionReason];
+interface DisconnectionDetails {
+    reason: DisconnectionReason;
+    message?: string;
+    code?: number;
+    timestamp: Date;
+}
+interface SessionConfig {
+    agentId: string;
+    authorization?: string;
+    overrides?: {
+        prompt?: string;
+        firstMessage?: string;
+        language?: string;
+        voiceId?: string;
+    };
+    userId?: string;
+}
+type OnDisconnectCallback = (details: DisconnectionDetails) => void;
+type OnMessageCallback = (event: IncomingMessage) => void;
+type OnStatusChangeCallback = (status: ConnectionStatus) => void;
+type OnOpenCallback = () => void;
+type OnErrorCallback = (error: Error) => void;
+
+/**
+ * Abstract base class for all connection types
+ */
+
+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;
+}
+
+/**
+ * WebSocket implementation of BaseConnection
+ */
+
+interface WebSocketConnectionConfig extends SessionConfig {
+    serverUrl: string;
+    auth: {
+        sessionToken: string;
+        sessionId: string;
+    };
+    reconnect?: boolean;
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+}
+declare class WebSocketConnection extends BaseConnection {
+    readonly conversationId: string;
+    private socket;
+    private config;
+    private authenticated;
+    constructor(config: WebSocketConnectionConfig);
+    /**
+     * Establish WebSocket connection
+     */
+    private connect;
+    /**
+     * Build WebSocket connection URL with session config
+     */
+    private buildConnectionUrl;
+    /**
+     * Handle WebSocket open event
+     */
+    private handleOpen;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleSocketMessage;
+    /**
+     * Handle WebSocket errors
+     */
+    private handleError;
+    /**
+     * Handle WebSocket close event
+     */
+    private handleClose;
+    /**
+     * Send a message through the WebSocket
+     */
+    sendMessage(message: OutgoingSocketMessage): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): void;
+    /**
+     * Check if the WebSocket is connected
+     */
+    isConnected(): boolean;
+    handleConnected(): void;
+}
+
+/**
+ * Server-Sent Events implementation of BaseConnection.
+ *
+ * Unlike the classic GET + EventSource pattern, this server streams events
+ * back as the response body of a POST to /chat. The request body is the
+ * same OutgoingSocketMessage envelope used over the WebSocket, so
+ * MessageManager parsing is shared.
+ *
+ * Wire shape:
+ *   POST  {serverUrl}/med-assist/session/{sessionId}/chat
+ *   Headers: Content-Type: application/json
+ *            Accept:       text/event-stream
+ *            sess-token:   <session token>
+ *            x-agent-id:   <agent id>
+ *   Body:    JSON-encoded OutgoingSocketMessage
+ *   Response: text/event-stream with `data: <json>\n\n` frames whose payloads
+ *             match the IncomingSocketMessage shape.
+ */
+
+interface SSEConnectionConfig extends SessionConfig {
+    serverUrl: string;
+    auth: {
+        sessionToken: string;
+        sessionId: string;
+    };
+}
+declare class SSEConnection extends BaseConnection {
+    readonly conversationId: string;
+    private config;
+    private connected;
+    private activeStreamController;
+    constructor(config: SSEConnectionConfig);
+    /**
+     * "Open" the SSE channel. There is no persistent socket — the connection
+     * is considered ready as soon as the session/agent identifiers are set.
+     * Each outgoing message opens its own short-lived streaming response.
+     *
+     * The open callback is deferred to a macrotask so it fires AFTER
+     * `Synapse.startSession()` resolves and the consumer (e.g. widget's
+     * `setUpEventListeners`) has had a chance to register the CONNECTED
+     * listener. With WebSocket the real socket open is naturally async; we
+     * have to simulate that here, otherwise the CONNECTED event is emitted
+     * before anyone is listening for it.
+     */
+    private connect;
+    /**
+     * Fire the open callback if the connection is already up by the time
+     * the listener registers. Mirrors the queued-disconnect pattern in
+     * BaseConnection so late-registering consumers don't miss the open
+     * event. Deferred via setTimeout for the same reason as connect().
+     */
+    onOpen(callback: OnOpenCallback): void;
+    private buildChatUrl;
+    /**
+     * Send an outgoing message. POSTs the same envelope used over the
+     * WebSocket and streams the response back as SSE-encoded events.
+     */
+    sendMessage(message: OutgoingSocketMessage): void;
+    private streamChat;
+    /**
+     * Walk the buffer and dispatch every complete top-level JSON object it
+     * contains, returning any trailing partial-object bytes that still need
+     * more data. The server streams back-to-back objects (`{…}{…}{…}`) with
+     * no separator, so we track brace depth (respecting strings/escapes)
+     * to find each object boundary. Any whitespace or stray SSE prefixes
+     * between objects is skipped automatically since we anchor on `{`.
+     */
+    private extractJsonObjects;
+    /**
+     * Return the index of the matching closing brace for the `{` at `start`,
+     * or -1 if the buffer ends before the object closes. String contents
+     * and escape sequences are skipped so braces inside strings don't
+     * affect the depth count.
+     */
+    private findObjectEnd;
+    close(): void;
+    isConnected(): boolean;
+    handleConnected(): void;
+}
+
+/**
+ * Factory class to create the appropriate connection type
+ */
+
+declare const ConnectionType: {
+    readonly SOCKET: "socket";
+    readonly SSE: "sse";
+};
+type ConnectionType = (typeof ConnectionType)[keyof typeof ConnectionType];
+type ConnectionConfig = WebSocketConnectionConfig | SSEConnectionConfig;
+declare class ConnectionFactory {
+    /**
+     * Create a connection based on the specified type
+     */
+    static createConnection(type: ConnectionType, config: ConnectionConfig): Promise<BaseConnection>;
+}
+
+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";
+};
+type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+
+/**
+ * Shared types across the SDK
+ */
+
+interface SendMessageOptions {
+    message?: string;
+    messageId?: string;
+    files?: File[];
+    audio?: AudioMetaData;
+    toolCalled?: boolean;
+    tool_declined?: boolean;
+    tool_id?: string;
+    initial_prompts?: TInitalPrompt[];
+    tool_result?: Record<string, unknown>;
+    hidden?: boolean;
+}
+interface SynapseSDKOverrides {
+    prompt?: string;
+    firstMessage?: string;
+    language?: string;
+    primaryColor?: string;
+}
+/**
+ * Unified error shape exposed to SDK consumers.
+ * All internal errors (APIError, SessionError, ConnectionError, etc.)
+ * are normalized to this before reaching the client.
+ */
+interface TSynapseError {
+    /** Human-readable message suitable for display */
+    message: string;
+    /** Parsed API error body, when the error originated from an HTTP response */
+    error?: {
+        code?: string;
+        msg?: string;
+    } & Record<string, unknown>;
+    /** Internal error classification (e.g. "SESSION_ERROR", "CONNECTION_ERROR") */
+    code?: string;
+    /** HTTP status code, when applicable */
+    status?: number;
+    /** Extra context set by the SDK (stage, sessionId, etc.) */
+    context?: Record<string, unknown>;
+}
+interface SynapseSDKCallbacks {
+    onSessionRefreshed?: (sessionResponse: SessionResponse) => void;
+    onError?: (error: TSynapseError) => void;
+}
+interface SynapseSDKConfig {
+    agentId: string;
+    environment?: Environment$1;
+    userId?: string;
+    connectionType?: ConnectionType;
+    overrides?: SynapseSDKOverrides;
+    callbacks?: SynapseSDKCallbacks;
+    context?: TContext;
+    auth?: string;
+    authToken?: string;
+    serverUrl?: string;
+}
+interface ExistingSessionOptions {
+    session_id: string;
+    session_token: string;
+}
+
+type Environment = "development" | "production" | "staging";
+
+declare const VOICE_AGENT_STATE: {
+    readonly IDLE: "idle";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly LISTENING: "listening";
+    readonly THINKING: "thinking";
+    readonly SPEAKING: "speaking";
+    readonly MUTED: "muted";
+    readonly DISCONNECTING: "disconnecting";
+    readonly ERROR: "error";
+};
+type VOICE_AGENT_STATE = (typeof VOICE_AGENT_STATE)[keyof typeof VOICE_AGENT_STATE];
+declare const VOICE_AGENT_EVENTS: {
+    readonly STATE_CHANGED: "voice:state_changed";
+    readonly ERROR: "voice:error";
+};
+type VOICE_AGENT_EVENTS = (typeof VOICE_AGENT_EVENTS)[keyof typeof VOICE_AGENT_EVENTS];
+interface VoiceAgentConfig {
+    baseUrl?: string;
+    offerUrl?: string;
+    handleRefresh?: () => Promise<void>;
+    iceServers?: RTCIceServer[];
+    iceGatheringTimeoutMs?: number;
+    speakingThreshold?: number;
+    environment?: Environment;
+}
+interface VoiceSessionCredentials {
+    sessionId: string;
+    sessionToken: string;
+}
+interface VoiceError {
+    message: string;
+    cause?: unknown;
+}
+
+interface IceServersResponse {
+    ice_servers: RTCIceServer[];
+}
+interface VoiceOfferRequest {
+    sdp: string;
+    type: string;
+    pc_id: string | null;
+    request_data: {
+        session_id: string;
+        token: string;
+    };
+}
+interface VoiceOfferResponse extends ResourceResponse {
+    sdp: string;
+    type: string;
+    pc_id: string;
+}
+
+/**
+ * Init class to fetch agent configuration from the platform
+ */
+
+declare class ResourceManager {
+    private resourceConfig;
+    private httpClient;
+    private session;
+    private config;
+    private voiceResource;
+    constructor(config: ResourceConfig);
+    /**
+     * Fetch agent configuration and create session
+     */
+    createSession(userId?: string, context?: TContext): Promise<SessionResponse>;
+    getAgentConfig(): Promise<AgentConfigResponse>;
+    /**
+     * Validate a session if it's still active or not
+     * GET /med-assist/session/:sessionId
+     */
+    validateSession(sessionId: string): Promise<{
+        expired: boolean;
+        active: boolean;
+    }>;
+    /**
+     * Refresh a session
+     * POST /med-assist/session/:sessionId/refresh
+     */
+    refreshSession(sessionId: string, sessionToken: string): Promise<SessionResponse>;
+    /**
+     * Feedback on a message
+     * PATCH /med-assist/session/:sessionId/:messageId
+     */
+    sendFeedback(sessionId: string, messageId: string, feedback: USER_FEEDBACK, feedbackReason?: string): Promise<void>;
+    /**
+     * Call a tool
+     * POST /med-assist/api-call-tool
+     */
+    callTool(sessionId: string, toolId: string, message_id: string, session_token: string, toolParams?: Record<string, unknown>): Promise<ToolCallResponse>;
+    getVoiceIceServers(sessionId: string, sessionToken: string): Promise<IceServersResponse>;
+    sendVoiceOffer(body: VoiceOfferRequest): Promise<VoiceOfferResponse>;
+}
+
+declare class VoiceAgent {
+    private config;
+    private resourceManager;
+    private getCredentials;
+    private emitter;
+    private remoteAnalyser;
+    private localAnalyser;
+    private pc;
+    private pcId;
+    private dataChannel;
+    private localStream;
+    private remoteAudio;
+    private _state;
+    private _isMuted;
+    private manuallyDisconnected;
+    private _hasConnectionFailureNotified;
+    private _userSpeaking;
+    private _silenceTimer;
+    private _cachedIceServers;
+    private _iceServersCachedAt;
+    constructor(config: VoiceAgentConfig, resourceManager: ResourceManager, getCredentials: () => Promise<VoiceSessionCredentials>);
+    get state(): VOICE_AGENT_STATE;
+    get isMuted(): boolean;
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    off(event: string, listener: (...args: unknown[]) => void): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    toggleMute(): void;
+    reset(): void;
+    destroy(): void;
+    private fetchIceServers;
+    private setState;
+    private clearSilenceTimer;
+    private handleConnectionFailure;
+    private releaseResources;
+    private startLocalAudioAnalysis;
+    private handleRemoteTrack;
+}
+
+/**
+ * High-level SynapseSDK API
+ * Provides a simple interface for managing chat sessions
+ */
+
+declare class SynapseSDK {
+    private connection;
+    private messageManager;
+    private resourceManager;
+    private sessionConfig;
+    private config;
+    private connectionType;
+    private isRefreshingSession;
+    private connectionAttempts;
+    private sdkEventEmitter;
+    private _voice;
+    constructor(config: SynapseSDKConfig);
+    /**
+     * Start the session
+     * if existing session is provided, it will be validated and refreshed
+     * if no existing session is provided, a new session will be created
+     * then the connection will be initialized and event handlers will be setup
+     * return the session response
+     */
+    startSession(existingSession?: ExistingSessionOptions): Promise<SessionResponse>;
+    /**
+     * Send a message conetnt will be text always
+     */
+    sendMessage({ message, files, audio, tool_declined, tool_id, initial_prompts, tool_result }: SendMessageOptions): Promise<void>;
+    /**
+     * Send feedback on a message
+     */
+    sendFeedback(messageId: string, feedback: USER_FEEDBACK, reason?: string): Promise<void>;
+    /**
+     * Register a listener for a specific event
+     */
+    on(event: SYNAPSE_REALTIME_EVENTS, listener: (...args: unknown[]) => void): void;
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event: SYNAPSE_REALTIME_EVENTS, listener: (...args: unknown[]) => void): void;
+    /**
+     * Get the session ID
+     */
+    getSessionConfig(): SessionResponse;
+    /**
+     * Call tool
+     */
+    callTool(tool_id: string, message_id: string, params?: Record<string, unknown>): Promise<void>;
+    /**
+     * Send audio
+     * */
+    startRecording({ onChunks, onError, }: {
+        onChunks: (chunks: AudioMetaData) => void;
+        onError?: (error: Error) => void;
+    }): Promise<void>;
+    /**
+     * Stop recording audio
+     */
+    endRecording(): void;
+    getAgentConfig(): Promise<AgentConfigResponse>;
+    isConnected(): boolean;
+    get voice(): VoiceAgent;
+    /**
+     * End the session
+     */
+    endSession(): void;
+    private buildVoiceConfig;
+    private toClientError;
+    private emitError;
+    private toSessionError;
+    /**
+     * Initialize the connection
+     * eg: socket connection or polling connection
+     */
+    private initializeConnection;
+    /**
+     * Resolve the session
+     * function to decide whether to create a new session or refresh the existing session
+     */
+    private manageSession;
+    /**
+     * Refresh the session
+     */
+    private refreshSession;
+    /**
+     * Create a new session
+     */
+    private createNewSession;
+    /**
+     * Set up event handlers for connection and messages
+     */
+    private setupEventHandlers;
+    /**
+     * Handle socket error
+     */
+    private onSocketConnectionError;
+    /**
+     * Handle socket connection open
+     */
+    private onSocketConnectionOpen;
+    /**
+     * Handle incoming socket messages
+     */
+    private onIncomingSocketMessage;
+    /**
+     * Handle session expired
+     */
+    private handleSessionExpiry;
+    private toConnectionError;
+    private closeConnection;
+    private cleanup;
+}
+
+interface RequestOptions {
+    body?: unknown;
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+    retries?: number;
+}
+
+interface HttpClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    authorization?: string;
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private baseUrl;
+    private headers;
+    private timeout;
+    private maxRetries;
+    constructor(config: HttpClientConfig);
+    private request;
+    get<T>(path: string, params?: Record<string, string>, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    private buildUrl;
+    private handleError;
+}
+
+/**
+ * Base class for all resources
+ */
+
+declare abstract class BaseResource {
+    protected client: HttpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Helper method for making GET requests
+     */
+    protected get<T>(path: string, params?: Record<string, string>, options?: RequestOptions): Promise<T>;
+    /**
+     * Helper method for making POST requests
+     */
+    protected post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Helper method for making PUT requests
+     */
+    protected put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Helper method for making DELETE requests
+     */
+    protected delete<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Helper method for making PATCH requests
+     */
+    protected patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Build a path with parameters
+     * Example: buildPath('/sessions/:id', { id: '123' }) => '/sessions/123'
+     */
+    protected buildPath(template: string, params: Record<string, string>): string;
+}
+
+/**
+ * SessionsResource class for managing sessions-related api calls
+ */
+declare class Session extends BaseResource {
+    /**
+     * create a new session
+     * POST /med-assist/session
+     */
+    private basePath;
+    create(sessionRequest: SessionCreateRequest, authToken?: string): Promise<SessionResponse>;
+    retrieve(sessionId: string): Promise<SessionResponse>;
+    /**
+     * refresh a session
+     * POST /med-assist/session/refresh
+     */
+    refresh(sessionId: string, sessionToken: string): Promise<SessionResponse>;
+    feedback(sessionId: string, messageId: string, feedback: USER_FEEDBACK, feedback_reason?: string): Promise<void>;
+    callTool(sessionId: string, toolId: string, messageId: string, sessionToken: string, toolParams?: Record<string, unknown>): Promise<ToolCallResponse>;
+}
+
+declare class ToolCall extends BaseResource {
+    private basePath;
+    callTool(sessionId: string, toolName: string, toolParams?: Record<string, unknown>): Promise<ToolCallResponse>;
+}
+
+declare class MessageManager {
+    private connection;
+    private callbacks;
+    private fileManager;
+    private audioManager;
+    private outgoingBuffer;
+    constructor(callbacks?: SynapseSDKCallbacks);
+    setConnection(connection: BaseConnection): void;
+    /**
+     * Handle file upload process
+     */
+    private handleFileUploadProcess;
+    /**
+     * send chat message through socket
+     */
+    sendSocketMessage({ message, files, audio, urls, tool_declined, tool_id, tool_result, initial_prompts }: SocketChatRequestData): void;
+    /**
+     * Handle incoming chat message
+     */
+    handleIncomingSocketChatMessage(message: IncomingSocketChatMessage): void;
+    /**
+     * Handle incoming stream message
+     */
+    handleIncomingSocketStreamMessage(message: IncomingSocketStreamMessage): void;
+    handleDisconnect(details: DisconnectionDetails): void;
+    /**
+     * Handle incoming end of stream message
+     */
+    handleIncomingSocketEndOfStreamMessage(_message: IncomingSocketEndOfStreamMessage): void;
+    /**
+     * Handle incoming error message
+     */
+    handleIncomingSocketErrorMessage(message: IncomingSocketErrorMessage): void;
+    /**
+     * send authentication message
+     */
+    sendSocketAuthMessage(sessionToken: string): void;
+    /**
+     * send ping message
+     */
+    sendSocketPingMessage(): void;
+    /**
+     * send audio message
+     */
+    startRecording({ onChunks, onError, }: {
+        onChunks: (chunks: AudioMetaData) => void;
+        onError?: (error: Error) => void;
+    }): Promise<void>;
+    /**
+     * stop recording audio
+     */
+    endRecordingWithSocket(): void;
+    /**
+     * send pong message
+     */
+    sendSocketPongMessage(): void;
+    handleConnectionEstablished(): void;
+    private flushOutgoingBuffer;
+    /**
+     * Cleanup message service
+     */
+    cleanupMessageServerState(): void;
+    private emitError;
+    private toFileError;
+    private toRecordingError;
+    private assertConnection;
+}
+
+declare class ErrorUtils {
+    /**
+     * Check if an error is a specific API error type
+     */
+    static isAPIError(error: unknown): error is APIError<number, Headers, Record<string, unknown>>;
+    /**
+     * Check if an error is a network-related error
+     */
+    static isNetworkError(error: unknown): boolean;
+    /**
+     * Check if an error is a timeout error
+     */
+    static isTimeoutError(error: unknown): boolean;
+    /**
+     * Check if an error is an authentication error
+     */
+    static isAuthError(error: unknown): boolean;
+    /**
+     * Check if an error is a client error (4xx)
+     */
+    static isClientError(error: unknown): boolean;
+    /**
+     * Check if an error is a server error (5xx)
+     */
+    static isServerError(error: unknown): boolean;
+    /**
+     * Get user-friendly error message
+     */
+    static getUserFriendlyMessage(error: unknown): string;
+    /**
+     * Extract error details for logging
+     */
+    static getErrorDetails(error: unknown): {
+        type: string;
+        message: string;
+        code?: SynapseErrorCode | string;
+        status?: number;
+        timestamp?: Date;
+        stack?: string;
+        context?: Record<string, unknown>;
+        hint?: string;
+    };
+}
+
+declare enum SYNAPSE_CONVERSATION {
+    TEXT = "text",
+    FILE = "file",
+    AUDIO = "audio",
+    VOICE = "voice"
+}
+
+export { APIConnectionTimeoutError, APIError, APIUserAbortError, type AgentConfig, type AgentConfigResponse, type AudioConfig, type AudioDataCallback, type AudioErrorCallback, type AudioMetaData, type AuthSynapseToMatrixMessage, BadRequestError, BaseConnection, type BaseMessage, type ChatMatrixToSynapseMessage, type ChatSynapseToMatrixMessage, type ConnectionConfig, type ConnectionEstablishedMatrixToSynapseMessage, ConnectionFactory, ConnectionStatus, ConnectionType, type ContentType, type DisconnectionDetails, DisconnectionReason, type EndOfStreamMatrixToSynapseMessage, type EndOfStreamSynapseToMatrixMessage, type Environment, type ErrorMessage, ErrorType, ErrorUtils, type ExistingSessionOptions, HttpClient, type HttpClientConfig, type IncomingMessage, InternalServerError, MessageManager, MethodNotAllowedError, NotFoundError, type OnDisconnectCallback, type OnErrorCallback, type OnMessageCallback, type OnOpenCallback, type OnStatusChangeCallback, type OutgoingMessage, PermissionDeniedError, type PingMessage, type PongMessage, RateLimitError, type ResourceConfig, ResourceManager, type ResourceResponse, type SOCKET_STREAM_DATA, SSEConnection, type SSEConnectionConfig, SYNAPSE_COMPONENTS, SYNAPSE_CONVERSATION, SYNAPSE_EICITATION_STATUS, SYNAPSE_MESSAGE_TYPES, SYNAPSE_REALTIME_ERROR_CODES, SYNAPSE_REALTIME_EVENTS, SYNAPSE_REALTIME_RESERVED_EVENTS, SYNAPSE_TOOL_CALLBACK_NAME, SYNAPSE_TOOL_NAME, type SYNAPSE_TOOL_TYPES, type SendMessageOptions, Session, type SessionConfig, type SessionCreateRequest, type SessionResponse, type SocketChatRequestData, type StreamMatrixToSynapseMessage, type StreamSynapseToMatrixMessage, type SynapseContentTypes, SynapseError, SynapseErrorCode, type SynapseInputCompMap, type SynapseRealTimeEventData, SynapseSDK, type SynapseSDKCallbacks, type SynapseSDKConfig, type SynapseSDKOverrides, type SynapseSelectedCompMap, type SyncMessage, type TAvailability, type TAvailabilityDatesToolResponse, type TAvailabilitySlotsToolResponse, type TCardCta, type TCardInput, type TCardItem, type TCardTheme, type TContext, type TDoctorAvailability, type TDoctorCardInput, type TDoctorDetails, type TDoctorDetailsMap, type TDoctorToolResponse, type TGetLocationToolResponse, type THospital, type TInitalPrompt, type TInitialMessage, type TMediaCard, type TOption, type TProfile, type TSynapseError, ToolCall, type ToolCallData, type ToolCallResponse, type ToolCallbacks, type ToolDetails, type ToolInputTypes, USER_FEEDBACK, UnauthorizedError, VOICE_AGENT_EVENTS, VOICE_AGENT_STATE, type VoiceAgentConfig, type VoiceError, type VoiceSessionCredentials, WebSocketConnection, type presignedUrls };