hume 0.1.0 → 0.2.5

package/dist/wrapper/HumeBatchClient.d.ts

@@ -0,0 +1,6 @@
+import { HumeClient as FernClient } from "../Client";
+import * as Hume from "../api";
+import { Job } from "./Job";
+export declare class HumeBatchClient extends FernClient {
+    submitJob(request?: Hume.BaseRequest, requestOptions?: FernClient.RequestOptions): Promise<Job>;
+}

package/dist/wrapper/HumeBatchClient.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeBatchClient = void 0;
+const Client_1 = require("../Client");
+const Job_1 = require("./Job");
+class HumeBatchClient extends Client_1.HumeClient {
+    submitJob(request = {}, requestOptions) {
+        const _super = Object.create(null, {
+            submitJob: { get: () => super.submitJob }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { jobId } = yield _super.submitJob.call(this, request, requestOptions);
+            return new Job_1.Job(jobId, this);
+        });
+    }
+}
+exports.HumeBatchClient = HumeBatchClient;

package/dist/wrapper/HumeStreamingClient.d.ts

@@ -0,0 +1,23 @@
+import * as Hume from "../api";
+import * as core from "../core";
+import { StreamSocket } from "./StreamSocket";
+export declare namespace HumeStreamingClient {
+    interface Options {
+        apiKey: core.Supplier<string>;
+        openTimeoutInSeconds?: number;
+    }
+    interface ConnectArgs {
+        config: Hume.ModelConfig;
+        streamWindowMs?: number;
+        onOpen?: () => void;
+        onMessage?: (message: Hume.ModelResponse) => void;
+        onWarning?: (error: Hume.ModelsWarning) => void;
+        onError?: (error: Hume.ModelsError) => void;
+        onClose?: () => void;
+    }
+}
+export declare class HumeStreamingClient {
+    protected readonly _options: HumeStreamingClient.Options;
+    constructor(_options: HumeStreamingClient.Options);
+    connect(args: HumeStreamingClient.ConnectArgs): Promise<StreamSocket>;
+}

package/dist/wrapper/HumeStreamingClient.js

@@ -0,0 +1,125 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeStreamingClient = void 0;
+const core = __importStar(require("../core"));
+const serializers = __importStar(require("../serialization"));
+const StreamSocket_1 = require("./StreamSocket");
+const ws_1 = __importDefault(require("ws"));
+class HumeStreamingClient {
+    constructor(_options) {
+        this._options = _options;
+    }
+    connect(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const websocket = new ws_1.default(`wss://api.hume.ai/v0/stream/models`, {
+                headers: {
+                    "X-Hume-Api-Key": yield core.Supplier.get(this._options.apiKey),
+                },
+                timeout: this._options.openTimeoutInSeconds,
+            });
+            websocket.addEventListener("open", () => {
+                var _a;
+                (_a = args.onOpen) === null || _a === void 0 ? void 0 : _a.call(args);
+            });
+            websocket.addEventListener("error", (e) => {
+                var _a;
+                (_a = args.onError) === null || _a === void 0 ? void 0 : _a.call(args, {
+                    code: e.type,
+                    error: e.message,
+                });
+            });
+            websocket.addEventListener("message", ({ data }) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const body = JSON.parse(data);
+                const parsedResponse = yield serializers.ModelResponse.parse(body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    breadcrumbsPrefix: ["response"],
+                });
+                if (parsedResponse.ok) {
+                    (_a = args.onMessage) === null || _a === void 0 ? void 0 : _a.call(args, parsedResponse.value);
+                    return;
+                }
+                const parsedWarning = yield serializers.ModelsWarning.parse(body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    breadcrumbsPrefix: ["response"],
+                });
+                if (parsedWarning.ok) {
+                    (_b = args.onWarning) === null || _b === void 0 ? void 0 : _b.call(args, parsedWarning.value);
+                    return;
+                }
+                const parsedError = yield serializers.ModelsError.parse(body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    breadcrumbsPrefix: ["response"],
+                });
+                if (parsedError.ok) {
+                    (_c = args.onError) === null || _c === void 0 ? void 0 : _c.call(args, parsedError.value);
+                    return;
+                }
+            }));
+            websocket.addEventListener("close", () => {
+                var _a;
+                (_a = args.onClose) === null || _a === void 0 ? void 0 : _a.call(args);
+            });
+            return new Promise((resolve) => {
+                if (websocket && websocket.readyState !== websocket.OPEN) {
+                    websocket.addEventListener("open", () => {
+                        resolve(new StreamSocket_1.StreamSocket({
+                            websocket,
+                            streamWindowMs: args.streamWindowMs,
+                            config: args.config,
+                        }));
+                    });
+                }
+                else {
+                    resolve(new StreamSocket_1.StreamSocket({
+                        websocket,
+                        streamWindowMs: args.streamWindowMs,
+                        config: args.config,
+                    }));
+                }
+            });
+        });
+    }
+}
+exports.HumeStreamingClient = HumeStreamingClient;

package/dist/wrapper/Job.d.ts

@@ -0,0 +1,8 @@
+import * as Hume from "../api";
+import { HumeBatchClient } from "./HumeBatchClient";
+export declare class Job implements Hume.JobId {
+    readonly jobId: string;
+    private readonly client;
+    constructor(jobId: string, client: HumeBatchClient);
+    awaitCompletion(timeoutInSeconds?: number): Promise<void>;
+}

package/dist/wrapper/Job.js

@@ -0,0 +1,87 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const errors = __importStar(require("../errors"));
+class Job {
+    constructor(jobId, client) {
+        this.jobId = jobId;
+        this.client = client;
+    }
+    awaitCompletion(timeoutInSeconds = 300) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const poller = new JobCompletionPoller(this.jobId, this.client);
+                poller.start(resolve);
+                setTimeout(() => {
+                    poller.stop();
+                    reject(new errors.HumeTimeoutError());
+                }, timeoutInSeconds * 1000);
+            });
+        });
+    }
+}
+exports.Job = Job;
+class JobCompletionPoller {
+    constructor(jobId, client) {
+        this.jobId = jobId;
+        this.client = client;
+        this.isPolling = true;
+    }
+    start(onTerminal) {
+        this.isPolling = true;
+        this.poll(onTerminal);
+    }
+    stop() {
+        this.isPolling = false;
+    }
+    poll(onTerminal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jobDetails = yield this.client.getJobDetails(this.jobId);
+                if (jobDetails.state.status === "COMPLETED" ||
+                    jobDetails.state.status === "FAILED") {
+                    onTerminal();
+                    this.stop();
+                }
+            }
+            catch (_a) {
+                // swallow errors while polling
+            }
+            if (this.isPolling) {
+                setTimeout(() => this.poll(onTerminal), 1000);
+            }
+        });
+    }
+}

package/dist/wrapper/StreamSocket.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+import WebSocket from "ws";
+import * as Hume from "../api";
+export declare namespace StreamSocket {
+    interface Args {
+        websocket: WebSocket;
+        config: Hume.ModelConfig;
+        streamWindowMs?: number;
+    }
+}
+export declare class StreamSocket {
+    readonly websocket: WebSocket;
+    private readonly streamWindowMs?;
+    private config;
+    constructor({ websocket, config, streamWindowMs }: StreamSocket.Args);
+    /**
+     * Send a file on the `StreamSocket`
+     *
+     * @param filepath Path to media file to send on socket connection
+     * @param config List of model configurations.
+     * If set these configurations will overwrite any configurations
+     * set when initializing the `StreamSocket`
+     */
+    sendFile({ filepath, config, }: {
+        filepath: string;
+        config?: Hume.ModelConfig;
+    }): Promise<void>;
+    /**
+     * Send raw bytes on the `StreamSocket`
+     *
+     * @param buffer Raw bytes of media to send on socket connection
+     * @param config List of model configurations.
+     * If set these configurations will overwrite any configurations
+     * set when initializing the `StreamSocket`
+     */
+    sendBuffer({ buffer, config, }: {
+        buffer: Buffer;
+        config?: Hume.ModelConfig;
+    }): void;
+    /**
+     * Send text on the `StreamSocket`
+     *
+     * @param text Text to send to the language model.
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendText({ text, config, }: {
+        text: string;
+        config?: Hume.ModelConfig;
+    }): void;
+    /**
+     * Send facemesh landmarks on the `StreamSocket`
+     *
+     * @param landmarks List of landmark points for multiple faces.
+     * The shape of this 3-dimensional list should be (n, 478, 3) where n is the number
+     * of faces to be processed, 478 is the number of MediaPipe landmarks per face and 3
+     * represents the (x, y, z) coordinates of each landmark.
+     * @param config List of model configurations.
+     * If set these configurations will overwrite existing configurations
+     */
+    sendFacemesh({ landmarks, config, }: {
+        landmarks: number[][][];
+        config?: Hume.ModelConfig;
+    }): void;
+    /**
+     *
+     * Reset the streaming sliding window.
+     *
+     * Call this method when some media has been fully processed and you want to continue using the same
+     * streaming connection without leaking context across media samples.
+     */
+    reset(): void;
+    /**
+     *
+     * Get details associated with the current streaming connection.
+     *
+     */
+    getJobDetails(): void;
+    /**
+     * Closes the underlying socket.
+     */
+    close(): void;
+}

package/dist/wrapper/StreamSocket.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamSocket = void 0;
+const promises_1 = require("fs/promises");
+class StreamSocket {
+    constructor({ websocket, config, streamWindowMs }) {
+        this.websocket = websocket;
+        this.config = config;
+        this.streamWindowMs = streamWindowMs;
+    }
+    /**
+     * Send a file on the `StreamSocket`
+     *
+     * @param filepath Path to media file to send on socket connection
+     * @param config List of model configurations.
+     * If set these configurations will overwrite any configurations
+     * set when initializing the `StreamSocket`
+     */
+    sendFile({ filepath, config, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sendBuffer({
+                buffer: yield (0, promises_1.readFile)(filepath),
+                config,
+            });
+        });
+    }
+    /**
+     * Send raw bytes on the `StreamSocket`
+     *
+     * @param buffer Raw bytes of media to send on socket connection
+     * @param config List of model configurations.
+     * If set these configurations will overwrite any configurations
+     * set when initializing the `StreamSocket`
+     */
+    sendBuffer({ buffer, config, }) {
+        this.sendText({
+            text: buffer.toString("base64"),
+            config,
+        });
+    }
+    /**
+     * Send text on the `StreamSocket`
+     *
+     * @param text Text to send to the language model.
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendText({ text, config, }) {
+        if (config != null) {
+            this.config = config;
+        }
+        this.websocket.send(JSON.stringify({
+            data: text,
+            raw_text: true,
+            models: this.config,
+            stream_window_ms: this.streamWindowMs,
+        }));
+    }
+    /**
+     * Send facemesh landmarks on the `StreamSocket`
+     *
+     * @param landmarks List of landmark points for multiple faces.
+     * The shape of this 3-dimensional list should be (n, 478, 3) where n is the number
+     * of faces to be processed, 478 is the number of MediaPipe landmarks per face and 3
+     * represents the (x, y, z) coordinates of each landmark.
+     * @param config List of model configurations.
+     * If set these configurations will overwrite existing configurations
+     */
+    sendFacemesh({ landmarks, config, }) {
+        const stringifiedLandmarks = JSON.stringify(landmarks);
+        this.sendText({
+            text: Buffer.from(stringifiedLandmarks).toString("base64"),
+            config,
+        });
+    }
+    /**
+     *
+     * Reset the streaming sliding window.
+     *
+     * Call this method when some media has been fully processed and you want to continue using the same
+     * streaming connection without leaking context across media samples.
+     */
+    reset() {
+        this.websocket.send(JSON.stringify({
+            reset_stream: true,
+        }));
+    }
+    /**
+     *
+     * Get details associated with the current streaming connection.
+     *
+     */
+    getJobDetails() {
+        this.websocket.send(JSON.stringify({
+            job_details: true,
+        }));
+    }
+    /**
+     * Closes the underlying socket.
+     */
+    close() {
+        this.websocket.close();
+    }
+}
+exports.StreamSocket = StreamSocket;

package/environments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare const HumeEnvironment: {
+    readonly Default: "https://api.hume.ai";
+};
+export declare type HumeEnvironment = typeof HumeEnvironment.Default;

package/environments.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeEnvironment = void 0;
+exports.HumeEnvironment = {
+    Default: "https://api.hume.ai",
+};

package/errors/HumeError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class HumeError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    constructor({ message, statusCode, body }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+    });
+}

package/errors/HumeError.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeError = void 0;
+class HumeError extends Error {
+    constructor({ message, statusCode, body }) {
+        super(buildMessage({ message, statusCode, body }));
+        Object.setPrototypeOf(this, HumeError.prototype);
+        if (statusCode != null) {
+            this.statusCode = statusCode;
+        }
+        if (body !== undefined) {
+            this.body = body;
+        }
+    }
+}
+exports.HumeError = HumeError;
+function buildMessage({ message, statusCode, body, }) {
+    let lines = [];
+    if (message != null) {
+        lines.push(message);
+    }
+    if (statusCode != null) {
+        lines.push(`Status code: ${statusCode.toString()}`);
+    }
+    if (body != null) {
+        lines.push(`Body: ${JSON.stringify(body, undefined, 2)}`);
+    }
+    return lines.join("\n");
+}

package/errors/HumeTimeoutError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class HumeTimeoutError extends Error {
+    constructor();
+}

package/errors/HumeTimeoutError.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeTimeoutError = void 0;
+class HumeTimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        Object.setPrototypeOf(this, HumeTimeoutError.prototype);
+    }
+}
+exports.HumeTimeoutError = HumeTimeoutError;

package/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { HumeError } from "./HumeError";
+export { HumeTimeoutError } from "./HumeTimeoutError";

package/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumeTimeoutError = exports.HumeError = void 0;
+var HumeError_1 = require("./HumeError");
+Object.defineProperty(exports, "HumeError", { enumerable: true, get: function () { return HumeError_1.HumeError; } });
+var HumeTimeoutError_1 = require("./HumeTimeoutError");
+Object.defineProperty(exports, "HumeTimeoutError", { enumerable: true, get: function () { return HumeTimeoutError_1.HumeTimeoutError; } });

package/index.d.ts

@@ -0,0 +1,6 @@
+export * as Hume from "./api";
+export { HumeBatchClient } from "./wrapper/HumeBatchClient";
+export { HumeStreamingClient } from "./wrapper/HumeStreamingClient";
+export { Job } from "./wrapper/Job";
+export { HumeEnvironment } from "./environments";
+export { HumeError, HumeTimeoutError } from "./errors";

package/index.js

@@ -0,0 +1,38 @@
+"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.HumeTimeoutError = exports.HumeError = exports.HumeEnvironment = exports.Job = exports.HumeStreamingClient = exports.HumeBatchClient = exports.Hume = void 0;
+exports.Hume = __importStar(require("./api"));
+var HumeBatchClient_1 = require("./wrapper/HumeBatchClient");
+Object.defineProperty(exports, "HumeBatchClient", { enumerable: true, get: function () { return HumeBatchClient_1.HumeBatchClient; } });
+var HumeStreamingClient_1 = require("./wrapper/HumeStreamingClient");
+Object.defineProperty(exports, "HumeStreamingClient", { enumerable: true, get: function () { return HumeStreamingClient_1.HumeStreamingClient; } });
+var Job_1 = require("./wrapper/Job");
+Object.defineProperty(exports, "Job", { enumerable: true, get: function () { return Job_1.Job; } });
+var environments_1 = require("./environments");
+Object.defineProperty(exports, "HumeEnvironment", { enumerable: true, get: function () { return environments_1.HumeEnvironment; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "HumeError", { enumerable: true, get: function () { return errors_1.HumeError; } });
+Object.defineProperty(exports, "HumeTimeoutError", { enumerable: true, get: function () { return errors_1.HumeTimeoutError; } });