hume 0.7.2 → 0.8.0

package/core/websocket/ws.js

@@ -0,0 +1,432 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectingWebSocket = void 0;
+const Events = __importStar(require("./events"));
+const getGlobalWebSocket = () => {
+    if (typeof WebSocket !== 'undefined') {
+        // @ts-ignore
+        return WebSocket;
+    }
+};
+/**
+ * Returns true if given argument looks like a WebSocket class
+ */
+const isWebSocket = (w) => typeof w !== 'undefined' && !!w && w.CLOSING === 2;
+const DEFAULT = {
+    maxReconnectionDelay: 10000,
+    minReconnectionDelay: 1000 + Math.random() * 4000,
+    minUptime: 5000,
+    reconnectionDelayGrowFactor: 1.3,
+    connectionTimeout: 4000,
+    maxRetries: Infinity,
+    maxEnqueuedMessages: Infinity,
+    startClosed: false,
+    debug: false,
+};
+class ReconnectingWebSocket {
+    constructor(url, protocols, options = {}) {
+        this._listeners = {
+            error: [],
+            message: [],
+            open: [],
+            close: [],
+        };
+        this._retryCount = -1;
+        this._shouldReconnect = true;
+        this._connectLock = false;
+        this._binaryType = 'blob';
+        this._closeCalled = false;
+        this._messageQueue = [];
+        /**
+         * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+         */
+        this.onclose = null;
+        /**
+         * An event listener to be called when an error occurs
+         */
+        this.onerror = null;
+        /**
+         * An event listener to be called when a message is received from the server
+         */
+        this.onmessage = null;
+        /**
+         * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+         * this indicates that the connection is ready to send and receive data
+         */
+        this.onopen = null;
+        this._handleOpen = (event) => {
+            this._debug('open event');
+            const { minUptime = DEFAULT.minUptime } = this._options;
+            clearTimeout(this._connectTimeout);
+            this._uptimeTimeout = setTimeout(() => this._acceptOpen(), minUptime);
+            this._ws.binaryType = this._binaryType;
+            // send enqueued messages (messages sent before websocket open event)
+            this._messageQueue.forEach(message => { var _a; return (_a = this._ws) === null || _a === void 0 ? void 0 : _a.send(message); });
+            this._messageQueue = [];
+            if (this.onopen) {
+                this.onopen(event);
+            }
+            this._listeners.open.forEach(listener => this._callEventListener(event, listener));
+        };
+        this._handleMessage = (event) => {
+            this._debug('message event');
+            if (this.onmessage) {
+                this.onmessage(event);
+            }
+            this._listeners.message.forEach(listener => this._callEventListener(event, listener));
+        };
+        this._handleError = (event) => {
+            this._debug('error event', event.message);
+            this._disconnect(undefined, event.message === 'TIMEOUT' ? 'timeout' : undefined);
+            if (this.onerror) {
+                this.onerror(event);
+            }
+            this._debug('exec error listeners');
+            this._listeners.error.forEach(listener => this._callEventListener(event, listener));
+            this._connect();
+        };
+        this._handleClose = (event) => {
+            this._debug('close event');
+            this._clearTimeouts();
+            if (this._shouldReconnect) {
+                this._connect();
+            }
+            if (this.onclose) {
+                this.onclose(event);
+            }
+            this._listeners.close.forEach(listener => this._callEventListener(event, listener));
+        };
+        this._url = url;
+        this._protocols = protocols;
+        this._options = options;
+        if (this._options.startClosed) {
+            this._shouldReconnect = false;
+        }
+        this._connect();
+    }
+    static get CONNECTING() {
+        return 0;
+    }
+    static get OPEN() {
+        return 1;
+    }
+    static get CLOSING() {
+        return 2;
+    }
+    static get CLOSED() {
+        return 3;
+    }
+    get CONNECTING() {
+        return ReconnectingWebSocket.CONNECTING;
+    }
+    get OPEN() {
+        return ReconnectingWebSocket.OPEN;
+    }
+    get CLOSING() {
+        return ReconnectingWebSocket.CLOSING;
+    }
+    get CLOSED() {
+        return ReconnectingWebSocket.CLOSED;
+    }
+    get binaryType() {
+        return this._ws ? this._ws.binaryType : this._binaryType;
+    }
+    set binaryType(value) {
+        this._binaryType = value;
+        if (this._ws) {
+            this._ws.binaryType = value;
+        }
+    }
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount() {
+        return Math.max(this._retryCount, 0);
+    }
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount() {
+        const bytes = this._messageQueue.reduce((acc, message) => {
+            if (typeof message === 'string') {
+                acc += message.length; // not byte size
+            }
+            else if (message instanceof Blob) {
+                acc += message.size;
+            }
+            else {
+                acc += message.byteLength;
+            }
+            return acc;
+        }, 0);
+        return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+    }
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions() {
+        return this._ws ? this._ws.extensions : '';
+    }
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol() {
+        return this._ws ? this._ws.protocol : '';
+    }
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState() {
+        if (this._ws) {
+            return this._ws.readyState;
+        }
+        return this._options.startClosed
+            ? ReconnectingWebSocket.CLOSED
+            : ReconnectingWebSocket.CONNECTING;
+    }
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url() {
+        return this._ws ? this._ws.url : '';
+    }
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code = 1000, reason) {
+        this._closeCalled = true;
+        this._shouldReconnect = false;
+        this._clearTimeouts();
+        if (!this._ws) {
+            this._debug('close enqueued: no ws instance');
+            return;
+        }
+        if (this._ws.readyState === this.CLOSED) {
+            this._debug('close: already closed');
+            return;
+        }
+        this._ws.close(code, reason);
+    }
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code, reason) {
+        this._shouldReconnect = true;
+        this._closeCalled = false;
+        this._retryCount = -1;
+        if (!this._ws || this._ws.readyState === this.CLOSED) {
+            this._connect();
+        }
+        else {
+            this._disconnect(code, reason);
+            this._connect();
+        }
+    }
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data) {
+        if (this._ws && this._ws.readyState === this.OPEN) {
+            this._debug('send', data);
+            this._ws.send(data);
+        }
+        else {
+            const { maxEnqueuedMessages = DEFAULT.maxEnqueuedMessages } = this._options;
+            if (this._messageQueue.length < maxEnqueuedMessages) {
+                this._debug('enqueue', data);
+                this._messageQueue.push(data);
+            }
+        }
+    }
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener(type, listener) {
+        if (this._listeners[type]) {
+            // @ts-ignore
+            this._listeners[type].push(listener);
+        }
+    }
+    dispatchEvent(event) {
+        const listeners = this._listeners[event.type];
+        if (listeners) {
+            for (const listener of listeners) {
+                this._callEventListener(event, listener);
+            }
+        }
+        return true;
+    }
+    /**
+     * Removes an event listener
+     */
+    removeEventListener(type, listener) {
+        if (this._listeners[type]) {
+            // @ts-ignore
+            this._listeners[type] = this._listeners[type].filter(l => l !== listener);
+        }
+    }
+    _debug(...args) {
+        if (this._options.debug) {
+            // not using spread because compiled version uses Symbols
+            // tslint:disable-next-line
+            console.log.apply(console, ['RWS>', ...args]);
+        }
+    }
+    _getNextDelay() {
+        const { reconnectionDelayGrowFactor = DEFAULT.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT.minReconnectionDelay, maxReconnectionDelay = DEFAULT.maxReconnectionDelay, } = this._options;
+        let delay = 0;
+        if (this._retryCount > 0) {
+            delay =
+                minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+            if (delay > maxReconnectionDelay) {
+                delay = maxReconnectionDelay;
+            }
+        }
+        this._debug('next delay', delay);
+        return delay;
+    }
+    _wait() {
+        return new Promise(resolve => {
+            setTimeout(resolve, this._getNextDelay());
+        });
+    }
+    _getNextUrl(urlProvider) {
+        if (typeof urlProvider === 'string') {
+            return Promise.resolve(urlProvider);
+        }
+        if (typeof urlProvider === 'function') {
+            const url = urlProvider();
+            if (typeof url === 'string') {
+                return Promise.resolve(url);
+            }
+            // @ts-ignore redundant check
+            if (url.then) {
+                return url;
+            }
+        }
+        throw Error('Invalid URL');
+    }
+    _connect() {
+        if (this._connectLock || !this._shouldReconnect) {
+            return;
+        }
+        this._connectLock = true;
+        const { maxRetries = DEFAULT.maxRetries, connectionTimeout = DEFAULT.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
+        if (this._retryCount >= maxRetries) {
+            this._debug('max retries reached', this._retryCount, '>=', maxRetries);
+            return;
+        }
+        this._retryCount++;
+        this._debug('connect', this._retryCount);
+        this._removeListeners();
+        if (!isWebSocket(WebSocket)) {
+            throw Error('No valid WebSocket class provided');
+        }
+        this._wait()
+            .then(() => this._getNextUrl(this._url))
+            .then(url => {
+            // close could be called before creating the ws
+            if (this._closeCalled) {
+                return;
+            }
+            this._debug('connect', { url, protocols: this._protocols });
+            this._ws = this._protocols
+                ? new WebSocket(url, this._protocols)
+                : new WebSocket(url);
+            this._ws.binaryType = this._binaryType;
+            this._connectLock = false;
+            this._addListeners();
+            this._connectTimeout = setTimeout(() => this._handleTimeout(), connectionTimeout);
+        });
+    }
+    _handleTimeout() {
+        this._debug('timeout event');
+        this._handleError(new Events.ErrorEvent(Error('TIMEOUT'), this));
+    }
+    _disconnect(code = 1000, reason) {
+        this._clearTimeouts();
+        if (!this._ws) {
+            return;
+        }
+        this._removeListeners();
+        try {
+            this._ws.close(code, reason);
+            this._handleClose(new Events.CloseEvent(code, reason, this));
+        }
+        catch (error) {
+            // ignore
+        }
+    }
+    _acceptOpen() {
+        this._debug('accept open');
+        this._retryCount = 0;
+    }
+    _callEventListener(event, listener) {
+        if ('handleEvent' in listener) {
+            // @ts-ignore
+            listener.handleEvent(event);
+        }
+        else {
+            // @ts-ignore
+            listener(event);
+        }
+    }
+    _removeListeners() {
+        if (!this._ws) {
+            return;
+        }
+        this._debug('removeListeners');
+        this._ws.removeEventListener('open', this._handleOpen);
+        this._ws.removeEventListener('close', this._handleClose);
+        this._ws.removeEventListener('message', this._handleMessage);
+        // @ts-ignore
+        this._ws.removeEventListener('error', this._handleError);
+    }
+    _addListeners() {
+        if (!this._ws) {
+            return;
+        }
+        this._debug('addListeners');
+        this._ws.addEventListener('open', this._handleOpen);
+        this._ws.addEventListener('close', this._handleClose);
+        this._ws.addEventListener('message', this._handleMessage);
+        // @ts-ignore
+        this._ws.addEventListener('error', this._handleError);
+    }
+    _clearTimeouts() {
+        clearTimeout(this._connectTimeout);
+        clearTimeout(this._uptimeTimeout);
+    }
+}
+exports.ReconnectingWebSocket = ReconnectingWebSocket;

package/dist/Client.d.ts

@@ -3,7 +3,6 @@
  */
 import * as environments from "./environments";
 import * as core from "./core";
-import { CustomModels } from "./api/resources/customModels/client/Client";
 import { EmpathicVoice } from "./api/resources/empathicVoice/client/Client";
 import { ExpressionMeasurement } from "./api/resources/expressionMeasurement/client/Client";
 export declare namespace HumeClient {
@@ -21,8 +20,6 @@ export declare namespace HumeClient {
 export declare class HumeClient {
     protected readonly _options: HumeClient.Options;
     constructor(_options?: HumeClient.Options);
-    protected _customModels: CustomModels | undefined;
-    get customModels(): CustomModels;
     protected _empathicVoice: EmpathicVoice | undefined;
     get empathicVoice(): EmpathicVoice;
     protected _expressionMeasurement: ExpressionMeasurement | undefined;

package/dist/Client.js

@@ -4,24 +4,19 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HumeClient = void 0;
-const Client_1 = require("./api/resources/customModels/client/Client");
-const Client_2 = require("./api/resources/empathicVoice/client/Client");
-const Client_3 = require("./api/resources/expressionMeasurement/client/Client");
+const Client_1 = require("./api/resources/empathicVoice/client/Client");
+const Client_2 = require("./api/resources/expressionMeasurement/client/Client");
 class HumeClient {
     constructor(_options = {}) {
         this._options = _options;
     }
-    get customModels() {
-        var _a;
-        return ((_a = this._customModels) !== null && _a !== void 0 ? _a : (this._customModels = new Client_1.CustomModels(this._options)));
-    }
     get empathicVoice() {
         var _a;
-        return ((_a = this._empathicVoice) !== null && _a !== void 0 ? _a : (this._empathicVoice = new Client_2.EmpathicVoice(this._options)));
+        return ((_a = this._empathicVoice) !== null && _a !== void 0 ? _a : (this._empathicVoice = new Client_1.EmpathicVoice(this._options)));
     }
     get expressionMeasurement() {
         var _a;
-        return ((_a = this._expressionMeasurement) !== null && _a !== void 0 ? _a : (this._expressionMeasurement = new Client_3.ExpressionMeasurement(this._options)));
+        return ((_a = this._expressionMeasurement) !== null && _a !== void 0 ? _a : (this._expressionMeasurement = new Client_2.ExpressionMeasurement(this._options)));
     }
 }
 exports.HumeClient = HumeClient;

package/dist/api/resources/empathicVoice/client/Client.d.ts

@@ -8,6 +8,7 @@ import { Prompts } from "../resources/prompts/client/Client";
 import { Configs } from "../resources/configs/client/Client";
 import { Chats } from "../resources/chats/client/Client";
 import { ChatGroups } from "../resources/chatGroups/client/Client";
+import { Chat } from "../resources/chat/client/Client";
 export declare namespace EmpathicVoice {
     interface Options {
         environment?: core.Supplier<environments.HumeEnvironment | string>;
@@ -33,4 +34,6 @@ export declare class EmpathicVoice {
     get chats(): Chats;
     protected _chatGroups: ChatGroups | undefined;
     get chatGroups(): ChatGroups;
+    protected _chat: Chat | undefined;
+    get chat(): Chat;
 }

package/dist/api/resources/empathicVoice/client/Client.js

@@ -9,6 +9,7 @@ const Client_2 = require("../resources/prompts/client/Client");
 const Client_3 = require("../resources/configs/client/Client");
 const Client_4 = require("../resources/chats/client/Client");
 const Client_5 = require("../resources/chatGroups/client/Client");
+const Client_6 = require("../resources/chat/client/Client");
 class EmpathicVoice {
     constructor(_options = {}) {
         this._options = _options;
@@ -33,5 +34,9 @@ class EmpathicVoice {
         var _a;
         return ((_a = this._chatGroups) !== null && _a !== void 0 ? _a : (this._chatGroups = new Client_5.ChatGroups(this._options)));
     }
+    get chat() {
+        var _a;
+        return ((_a = this._chat) !== null && _a !== void 0 ? _a : (this._chat = new Client_6.Chat(this._options)));
+    }
 }
 exports.EmpathicVoice = EmpathicVoice;

package/dist/api/resources/empathicVoice/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./resources";
 export * from "./types";
-export * from "./client";

package/dist/api/resources/empathicVoice/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./resources"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./client"), exports);

package/dist/api/resources/empathicVoice/resources/chat/client/Client.d.ts

@@ -0,0 +1,21 @@
+import * as core from "../../../../../../core";
+import { ChatSocket } from "./Socket";
+export declare namespace Chat {
+    interface Options {
+        apiKey?: core.Supplier<string | undefined>;
+        accessToken?: core.Supplier<string | undefined>;
+    }
+    interface ConnectArgs {
+        /** The ID of the configuration. */
+        configId?: string;
+        /** The version of the configuration. */
+        configVersion?: string;
+        /** The ID of a chat group, used to resume a previous chat. */
+        resumedChatGroupId?: string;
+    }
+}
+export declare class Chat {
+    protected readonly _options: Chat.Options;
+    constructor(_options: Chat.Options);
+    connect(args?: Chat.ConnectArgs): ChatSocket;
+}

package/dist/api/resources/empathicVoice/resources/chat/client/Client.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = void 0;
+const core = __importStar(require("../../../../../../core"));
+const qs_1 = __importDefault(require("qs"));
+const Socket_1 = require("./Socket");
+class Chat {
+    constructor(_options) {
+        this._options = _options;
+    }
+    connect(args = {}) {
+        const queryParams = {};
+        if (this._options.accessToken != null) {
+            queryParams["accessToken"] = core.Supplier.get(this._options.accessToken);
+        }
+        else if (this._options.apiKey != null) {
+            queryParams["apiKey"] = core.Supplier.get(this._options.apiKey);
+        }
+        if (args.configId != null) {
+            queryParams["config_id"] = args.configId;
+        }
+        if (args.configVersion != null) {
+            queryParams["config_version"] = args.configVersion;
+        }
+        if (args.resumedChatGroupId != null) {
+            queryParams["resumed_chat_group_id"] = args.resumedChatGroupId;
+        }
+        const socket = new core.ReconnectingWebSocket(`wss://api.hume.ai/v0/evi/chat?${qs_1.default.stringify(queryParams)}`);
+        return new Socket_1.ChatSocket({
+            socket,
+        });
+    }
+}
+exports.Chat = Chat;

package/dist/api/resources/empathicVoice/resources/chat/client/Socket.d.ts

@@ -0,0 +1,76 @@
+import * as core from "../../../../../../core";
+import * as Hume from "../../../../../index";
+export declare namespace ChatSocket {
+    interface Args {
+        socket: core.ReconnectingWebSocket;
+    }
+    type Response = Hume.empathicVoice.SubscribeEvent & {
+        receivedAt: number;
+    };
+    type EventHandlers = {
+        open?: () => void;
+        message?: (message: Response) => void;
+        close?: (event: core.CloseEvent) => void;
+        error?: (error: Error) => void;
+    };
+}
+export declare class ChatSocket {
+    readonly socket: core.ReconnectingWebSocket;
+    readonly readyState: number;
+    protected readonly eventHandlers: ChatSocket.EventHandlers;
+    constructor({ socket }: ChatSocket.Args);
+    /**
+     * @param event - The event to attach to.
+     * @param callback - The callback to run when the event is triggered.
+     *
+     * @example
+     * ```ts
+     * const socket = hume.empathicVoice.chat.connect({ apiKey: "...." });
+     * socket.on('open', () => {
+     *  console.log('Socket opened');
+     * });
+     * ```
+     */
+    on<T extends keyof ChatSocket.EventHandlers>(event: T, callback: ChatSocket.EventHandlers[T]): void;
+    /**
+     * Send audio input
+     */
+    sendAudioInput(message: Omit<Hume.empathicVoice.AudioInput, "type">): Promise<void>;
+    /**
+     * Send session settings
+     */
+    sendSessionSettings(message: Omit<Hume.empathicVoice.SessionSettings, "type">): Promise<void>;
+    /**
+     * Send assistant input
+     */
+    sendAssistantInput(message: Omit<Hume.empathicVoice.AssistantInput, "type">): Promise<void>;
+    /**
+     * Send pause assistant message
+     */
+    pauseAssistant(message: Omit<Hume.empathicVoice.PauseAssistantMessage, "type">): Promise<void>;
+    /**
+     * Send resume assistant message
+     */
+    resumeAssistant(message: Omit<Hume.empathicVoice.ResumeAssistantMessage, "type">): Promise<void>;
+    /**
+     * Send tool response message
+     */
+    sendToolResponseMessage(message: Omit<Hume.empathicVoice.ToolResponseMessage, "type">): Promise<void>;
+    /**
+     * Send tool error message
+     */
+    sendToolErrorMessage(message: Omit<Hume.empathicVoice.ToolErrorMessage, "type">): Promise<void>;
+    /**
+     * Send text input
+     */
+    sendUserInput(text: string): Promise<void>;
+    /**
+     * Closes the underlying socket.
+     */
+    close(): void;
+    private sendJson;
+    private handleOpen;
+    private handleMessage;
+    private handleClose;
+    private handleError;
+}