hume 0.15.8 → 0.15.10

package/dist/esm/core/pagination/CustomPager.mjs

@@ -0,0 +1,189 @@
+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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+/**
+ *
+ * @template TItem The type of the items in the page.
+ * @template TResponse The type of the API response.
+ */
+export class CustomPager {
+    constructor(args) {
+        this.response = args.response;
+        this.rawResponse = args.rawResponse;
+        this.data = args.items;
+        this._hasNextPage = args.hasNextPage;
+        this._hasPreviousPage = args.hasPreviousPage;
+        this.nextRequest = args.nextRequest;
+        this.previousRequest = args.previousRequest;
+        this.sendRequest = args.sendRequest;
+    }
+    /**
+     * @returns whether there is a next page to load
+     */
+    hasNextPage() {
+        return this._hasNextPage;
+    }
+    /**
+     * @returns whether there is a previous page to load
+     */
+    hasPreviousPage() {
+        return this._hasPreviousPage;
+    }
+    /**
+     * Returns the current page data.
+     * This is an alias for the `data` property for consistency with other pagination APIs.
+     *
+     * @returns the items from the current page
+     */
+    getCurrentPage() {
+        return this.data;
+    }
+    /**
+     * Retrieves the next page of results.
+     * @returns this pager with updated data
+     * @throws Error if there is no next page
+     */
+    getNextPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasNextPage || !this.nextRequest) {
+                throw new Error("No next page available");
+            }
+            const response = yield this.sendRequest(this.nextRequest);
+            if (!response.ok) {
+                const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+                throw new Error(`Failed to fetch next page: ${reason}`);
+            }
+            const data = response.body;
+            const rawResponse = response.rawResponse;
+            const parsed = yield parse({ request: this.nextRequest, data, rawResponse });
+            this.response = data;
+            this.rawResponse = rawResponse;
+            this.data = parsed.items;
+            this._hasNextPage = parsed.hasNextPage;
+            this._hasPreviousPage = parsed.hasPreviousPage;
+            this.nextRequest = parsed.nextRequest;
+            this.previousRequest = parsed.previousRequest;
+            return this;
+        });
+    }
+    /**
+     * Retrieves the previous page of results.
+     * @returns this pager with updated data
+     * @throws Error if there is no previous page
+     */
+    getPreviousPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasPreviousPage || !this.previousRequest) {
+                throw new Error("No previous page available");
+            }
+            const response = yield this.sendRequest(this.previousRequest);
+            if (!response.ok) {
+                const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+                throw new Error(`Failed to fetch previous page: ${reason}`);
+            }
+            const data = response.body;
+            const rawResponse = response.rawResponse;
+            const parsed = yield parse({ request: this.previousRequest, data, rawResponse });
+            this.response = data;
+            this.rawResponse = rawResponse;
+            this.data = parsed.items;
+            this._hasNextPage = parsed.hasNextPage;
+            this._hasPreviousPage = parsed.hasPreviousPage;
+            this.nextRequest = parsed.nextRequest;
+            this.previousRequest = parsed.previousRequest;
+            return this;
+        });
+    }
+    iterMessages() {
+        return __asyncGenerator(this, arguments, function* iterMessages_1() {
+            for (const item of this.data) {
+                yield yield __await(item);
+            }
+            while (this.hasNextPage()) {
+                yield __await(this.getNextPage());
+                for (const item of this.data) {
+                    yield yield __await(item);
+                }
+            }
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            var _b, e_1, _c, _d;
+            try {
+                for (var _e = true, _f = __asyncValues(this.iterMessages()), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+                    _d = _g.value;
+                    _e = false;
+                    const message = _d;
+                    yield yield __await(message);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+}
+export function createCustomPager(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ sendRequest, initialHttpRequest, clientOptions, }) {
+        const response = yield sendRequest(initialHttpRequest);
+        if (!response.ok) {
+            const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+            throw new Error(`Failed to fetch initial page: ${reason}`);
+        }
+        const data = response.body;
+        const rawResponse = response.rawResponse;
+        const parsed = yield parse({ request: initialHttpRequest, data, rawResponse });
+        return new CustomPager({
+            response: data,
+            rawResponse,
+            items: parsed.items,
+            hasNextPage: parsed.hasNextPage,
+            hasPreviousPage: parsed.hasPreviousPage,
+            nextRequest: parsed.nextRequest,
+            previousRequest: parsed.previousRequest,
+            sendRequest: sendRequest,
+        });
+    });
+}
+function parse(_args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Placeholder implementation.
+        // TODO: Replace this with actual parsing logic.
+        return {
+            items: [],
+            hasNextPage: false,
+            hasPreviousPage: false,
+        };
+    });
+}

package/dist/esm/core/pagination/index.d.mts

@@ -1 +1,2 @@
+export { CustomPager, createCustomPager } from "./CustomPager.mjs";
 export { Page } from "./Page.mjs";

package/dist/esm/core/pagination/index.mjs

@@ -1 +1,2 @@
+export { CustomPager, createCustomPager } from "./CustomPager.mjs";
 export { Page } from "./Page.mjs";

package/dist/esm/core/runtime/runtime.mjs

@@ -68,6 +68,17 @@ function evaluateRuntime() {
             version: Bun.version,
         };
     }
+    /**
+     * A constant that indicates whether the environment the code is running is in React-Native.
+     * This check should come before Node.js detection since React Native may have a process polyfill.
+     * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
+     */
+    const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
+    if (isReactNative) {
+        return {
+            type: "react-native",
+        };
+    }
     /**
      * A constant that indicates whether the environment the code is running is Node.JS.
      */
@@ -83,16 +94,6 @@ function evaluateRuntime() {
             parsedVersion: Number(process.versions.node.split(".")[0]),
         };
     }
-    /**
-     * A constant that indicates whether the environment the code is running is in React-Native.
-     * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
-     */
-    const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
-    if (isReactNative) {
-        return {
-            type: "react-native",
-        };
-    }
     return {
         type: "unknown",
     };

package/dist/esm/core/schemas/Schema.d.mts

@@ -20,6 +20,7 @@ export declare const SchemaType: {
     readonly NUMBER: "number";
     readonly STRING: "string";
     readonly UNKNOWN: "unknown";
+    readonly NEVER: "never";
     readonly RECORD: "record";
     readonly SET: "set";
     readonly UNION: "union";

package/dist/esm/core/schemas/Schema.mjs

@@ -11,6 +11,7 @@ export const SchemaType = {
     NUMBER: "number",
     STRING: "string",
     UNKNOWN: "unknown",
+    NEVER: "never",
     RECORD: "record",
     SET: "set",
     UNION: "union",

package/dist/esm/core/schemas/builders/object/object.mjs

@@ -176,6 +176,7 @@ export function getObjectUtils(schema) {
                         value: raw,
                         transformBase: (rawBase) => schema.parse(rawBase, opts),
                         transformExtension: (rawExtension) => extension.parse(rawExtension, opts),
+                        breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
                     });
                 },
                 json: (parsed, opts) => {
@@ -184,6 +185,7 @@ export function getObjectUtils(schema) {
                         value: parsed,
                         transformBase: (parsedBase) => schema.json(parsedBase, opts),
                         transformExtension: (parsedExtension) => extension.json(parsedExtension, opts),
+                        breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
                     });
                 },
                 getType: () => SchemaType.OBJECT,
@@ -220,7 +222,18 @@ export function getObjectUtils(schema) {
         },
     };
 }
-function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
+function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, breadcrumbsPrefix = [], }) {
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: getErrorMessageForIncorrectType(value, "object"),
+                },
+            ],
+        };
+    }
     const extensionPropertiesSet = new Set(extensionKeys);
     const [extensionProperties, baseProperties] = partition(keys(value), (key) => extensionPropertiesSet.has(key));
     const transformedBase = transformBase(filterObject(value, baseProperties));

package/dist/esm/core/schemas/builders/primitives/index.d.mts

@@ -1,5 +1,6 @@
 export { any } from "./any.mjs";
 export { boolean } from "./boolean.mjs";
+export { never } from "./never.mjs";
 export { number } from "./number.mjs";
 export { string } from "./string.mjs";
 export { unknown } from "./unknown.mjs";

package/dist/esm/core/schemas/builders/primitives/index.mjs

@@ -1,5 +1,6 @@
 export { any } from "./any.mjs";
 export { boolean } from "./boolean.mjs";
+export { never } from "./never.mjs";
 export { number } from "./number.mjs";
 export { string } from "./string.mjs";
 export { unknown } from "./unknown.mjs";

package/dist/esm/core/schemas/builders/primitives/never.d.mts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.mjs";
+export declare const never: () => Schema<never, never>;

package/dist/esm/core/schemas/builders/primitives/never.mjs

@@ -0,0 +1,11 @@
+import { SchemaType } from "../../Schema.mjs";
+import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator.mjs";
+export const never = createIdentitySchemaCreator(SchemaType.NEVER, (_value, { breadcrumbsPrefix = [] } = {}) => ({
+    ok: false,
+    errors: [
+        {
+            path: breadcrumbsPrefix,
+            message: "Expected never",
+        },
+    ],
+}));

package/dist/esm/core/url/join.mjs

@@ -11,7 +11,6 @@ export function join(base, ...segments) {
             url = new URL(base);
         }
         catch (_a) {
-            // Fallback to path joining if URL is malformed
             return joinPath(base, ...segments);
         }
         const lastSegment = segments[segments.length - 1];

package/dist/esm/errors/HumeError.mjs

@@ -3,7 +3,11 @@ import { toJson } from "../core/json.mjs";
 export class HumeError extends Error {
     constructor({ message, statusCode, body, rawResponse, }) {
         super(buildMessage({ message, statusCode, body }));
-        Object.setPrototypeOf(this, HumeError.prototype);
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = this.constructor.name;
         this.statusCode = statusCode;
         this.body = body;
         this.rawResponse = rawResponse;

package/dist/esm/errors/HumeTimeoutError.mjs

@@ -2,6 +2,10 @@
 export class HumeTimeoutError extends Error {
     constructor(message) {
         super(message);
-        Object.setPrototypeOf(this, HumeTimeoutError.prototype);
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = this.constructor.name;
     }
 }

package/dist/esm/errors/handleNonStatusCodeError.d.mts

@@ -0,0 +1,2 @@
+import type * as core from "../core/index.mjs";
+export declare function handleNonStatusCodeError(error: core.Fetcher.Error, rawResponse: core.RawResponse, method: string, path: string): never;

package/dist/esm/errors/handleNonStatusCodeError.mjs

@@ -0,0 +1,29 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as errors from "./index.mjs";
+export function handleNonStatusCodeError(error, rawResponse, method, path) {
+    switch (error.reason) {
+        case "non-json":
+            throw new errors.HumeError({
+                statusCode: error.statusCode,
+                body: error.rawBody,
+                rawResponse: rawResponse,
+            });
+        case "body-is-null":
+            throw new errors.HumeError({
+                statusCode: error.statusCode,
+                rawResponse: rawResponse,
+            });
+        case "timeout":
+            throw new errors.HumeTimeoutError(`Timeout exceeded when calling ${method} ${path}.`);
+        case "unknown":
+            throw new errors.HumeError({
+                message: error.errorMessage,
+                rawResponse: rawResponse,
+            });
+        default:
+            throw new errors.HumeError({
+                message: "Unknown error",
+                rawResponse: rawResponse,
+            });
+    }
+}

package/dist/esm/serialization/resources/empathicVoice/types/ReturnVoice.d.mts

@@ -6,8 +6,8 @@ export declare const ReturnVoice: core.serialization.ObjectSchema<serializers.em
 export declare namespace ReturnVoice {
     interface Raw {
         compatible_octave_models?: string[] | null;
-        id?: string | null;
-        name?: string | null;
-        provider?: VoiceProvider.Raw | null;
+        id: string;
+        name: string;
+        provider: VoiceProvider.Raw;
     }
 }

package/dist/esm/serialization/resources/empathicVoice/types/ReturnVoice.mjs

@@ -3,7 +3,7 @@ import * as core from "../../../../core/index.mjs";
 import { VoiceProvider } from "./VoiceProvider.mjs";
 export const ReturnVoice = core.serialization.object({
     compatibleOctaveModels: core.serialization.property("compatible_octave_models", core.serialization.list(core.serialization.string()).optional()),
-    id: core.serialization.string().optional(),
-    name: core.serialization.string().optional(),
-    provider: VoiceProvider.optional(),
+    id: core.serialization.string(),
+    name: core.serialization.string(),
+    provider: VoiceProvider,
 });

package/dist/esm/serialization/resources/tts/types/ReturnPagedVoices.d.mts

@@ -5,9 +5,9 @@ import { ReturnVoice } from "./ReturnVoice.mjs";
 export declare const ReturnPagedVoices: core.serialization.ObjectSchema<serializers.tts.ReturnPagedVoices.Raw, Hume.tts.ReturnPagedVoices>;
 export declare namespace ReturnPagedVoices {
     interface Raw {
-        page_number?: number | null;
-        page_size?: number | null;
-        total_pages?: number | null;
-        voices_page?: ReturnVoice.Raw[] | null;
+        page_number: number;
+        page_size: number;
+        total_pages: number;
+        voices_page: ReturnVoice.Raw[];
     }
 }

package/dist/esm/serialization/resources/tts/types/ReturnPagedVoices.mjs

@@ -2,8 +2,8 @@
 import * as core from "../../../../core/index.mjs";
 import { ReturnVoice } from "./ReturnVoice.mjs";
 export const ReturnPagedVoices = core.serialization.object({
-    pageNumber: core.serialization.property("page_number", core.serialization.number().optional()),
-    pageSize: core.serialization.property("page_size", core.serialization.number().optional()),
-    totalPages: core.serialization.property("total_pages", core.serialization.number().optional()),
-    voicesPage: core.serialization.property("voices_page", core.serialization.list(ReturnVoice).optional()),
+    pageNumber: core.serialization.property("page_number", core.serialization.number()),
+    pageSize: core.serialization.property("page_size", core.serialization.number()),
+    totalPages: core.serialization.property("total_pages", core.serialization.number()),
+    voicesPage: core.serialization.property("voices_page", core.serialization.list(ReturnVoice)),
 });

package/dist/esm/serialization/resources/tts/types/ReturnVoice.d.mts

@@ -6,8 +6,8 @@ export declare const ReturnVoice: core.serialization.ObjectSchema<serializers.tt
 export declare namespace ReturnVoice {
     interface Raw {
         compatible_octave_models?: string[] | null;
-        id?: string | null;
-        name?: string | null;
-        provider?: VoiceProvider.Raw | null;
+        id: string;
+        name: string;
+        provider: VoiceProvider.Raw;
     }
 }

package/dist/esm/serialization/resources/tts/types/ReturnVoice.mjs

@@ -3,7 +3,7 @@ import * as core from "../../../../core/index.mjs";
 import { VoiceProvider } from "./VoiceProvider.mjs";
 export const ReturnVoice = core.serialization.object({
     compatibleOctaveModels: core.serialization.property("compatible_octave_models", core.serialization.list(core.serialization.string()).optional()),
-    id: core.serialization.string().optional(),
-    name: core.serialization.string().optional(),
-    provider: VoiceProvider.optional(),
+    id: core.serialization.string(),
+    name: core.serialization.string(),
+    provider: VoiceProvider,
 });

package/dist/esm/version.d.mts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.15.8";
+export declare const SDK_VERSION = "0.15.10";

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.15.8";
+export const SDK_VERSION = "0.15.10";

package/dist/esm/wrapper/SilenceFiller.d.mts

@@ -1,10 +1,24 @@
-import { Readable } from "stream";
 /**
- * SilenceFiller is a Readable stream that intersperses incoming audio data
+ * A minimal Writable-like interface that SilenceFiller can pipe to.
+ * This matches the subset of Node.js Writable that we need.
+ */
+export interface PipeDestination {
+    write(chunk: Uint8Array): boolean;
+    end?(): void;
+    on?(event: "drain", listener: () => void): this;
+    once?(event: "drain", listener: () => void): this;
+    removeListener?(event: "drain", listener: () => void): this;
+}
+type EventListener = (...args: unknown[]) => void;
+/**
+ * SilenceFiller is a pipeable stream that intersperses incoming audio data
  * with bytes of silence. This is important in some cases to keep an audio
  * stream "alive". Audio players, such as ffmpeg, can interpret inactivity as
  * meaning the stream is ended, or disconnected.
  *
+ * This implementation does not depend on Node.js built-ins and can work in
+ * any JavaScript environment, while still being pipeable to Node.js streams.
+ *
  * @example
  * ```typescript
  * import { SilenceFiller } from 'hume';
@@ -29,12 +43,15 @@ import { Readable } from "stream";
  * await silenceFiller.endStream();
  * ```
  */
-export declare class SilenceFiller extends Readable {
+export declare class SilenceFiller {
     private unclockedSilenceFiller;
     private isStarted;
-    private pushInterval;
+    private pushIntervalId;
     private bytesPerSample;
     private pushIntervalMs;
+    private destination;
+    private eventListeners;
+    private ended;
     /**
      * Creates a new SilenceFiller instance.
      *
@@ -46,16 +63,52 @@ export declare class SilenceFiller extends Readable {
      * playback will take longer to start.
      */
     constructor(pushIntervalMs?: number, sampleRate?: number, bytesPerSample?: number, bufferSize?: number);
+    /**
+     * Pipes the output of this SilenceFiller to a writable destination.
+     *
+     * @param destination - The destination to pipe to (e.g., a Node.js Writable stream).
+     * @returns The destination, for chaining.
+     */
+    pipe<T extends PipeDestination>(destination: T): T;
+    /**
+     * Registers an event listener.
+     *
+     * @param event - The event name ('error', 'end').
+     * @param listener - The listener function.
+     * @returns This instance, for chaining.
+     */
+    on(event: string, listener: EventListener): this;
+    /**
+     * Registers a one-time event listener.
+     *
+     * @param event - The event name ('error', 'end').
+     * @param listener - The listener function.
+     * @returns This instance, for chaining.
+     */
+    once(event: string, listener: EventListener): this;
+    /**
+     * Removes an event listener.
+     *
+     * @param event - The event name.
+     * @param listener - The listener function to remove.
+     * @returns This instance, for chaining.
+     */
+    off(event: string, listener: EventListener): this;
+    /**
+     * Emits an event to all registered listeners.
+     *
+     * @param event - The event name.
+     * @param args - Arguments to pass to listeners.
+     */
+    private emit;
     /**
      * Writes audio data to the silence filler.
      *
-     * @param audioBuffer - The audio buffer to write.
+     * @param audioBuffer - The audio buffer to write (Uint8Array or Buffer).
      */
-    writeAudio(audioBuffer: Buffer): void;
+    writeAudio(audioBuffer: Uint8Array): void;
     private startPushInterval;
     private pushData;
-    _read(): void;
-    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
     /**
      * Ends the stream and drains all remaining audio data.
      *
@@ -80,6 +133,7 @@ export declare class UnclockedSilenceFiller {
     private sampleRate;
     private bytesPerSample;
     constructor(bufferSize: number, sampleRate: number, bytesPerSample: number);
-    writeAudio(audioBuffer: Buffer, timestamp: number): void;
-    readAudio(timestamp: number): Buffer | null;
+    writeAudio(audioBuffer: Uint8Array, timestamp: number): void;
+    readAudio(timestamp: number): Uint8Array | null;
 }
+export {};