import { TextEncoder, TextDecoder } from 'util';

let wasm;
function __wbg_set_wasm(exports, module) {
    wasm = exports;
}


let WASM_VECTOR_LEN = 0;

let cachedUint8ArrayMemory0 = null;

function getUint8ArrayMemory0() {
    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8ArrayMemory0;
}

let cachedTextEncoder = new TextEncoder('utf-8');

const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
    ? function (arg, view) {
    return cachedTextEncoder.encodeInto(arg, view);
}
    : function (arg, view) {
    const buf = cachedTextEncoder.encode(arg);
    view.set(buf);
    return {
        read: arg.length,
        written: buf.length
    };
});

function passStringToWasm0(arg, malloc, realloc) {

    if (realloc === undefined) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr = malloc(buf.length, 1) >>> 0;
        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }

    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8ArrayMemory0();

    let offset = 0;

    for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 0x7F) break;
        mem[ptr + offset] = code;
    }

    if (offset !== len) {
        if (offset !== 0) {
            arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);

        offset += ret.written;
        ptr = realloc(ptr, len, offset, 1) >>> 0;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
}

let cachedDataViewMemory0 = null;

function getDataViewMemory0() {
    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
    }
    return cachedDataViewMemory0;
}

let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

cachedTextDecoder.decode();

function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

function addToExternrefTable0(obj) {
    const idx = wasm.__externref_table_alloc();
    wasm.__wbindgen_export_4.set(idx, obj);
    return idx;
}

function handleError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        const idx = addToExternrefTable0(e);
        wasm.__wbindgen_exn_store(idx);
    }
}

function isLikeNone(x) {
    return x === undefined || x === null;
}

const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(state => {
    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
});

function makeMutClosure(arg0, arg1, dtor, f) {
    const state = { a: arg0, b: arg1, cnt: 1, dtor };
    const real = (...args) => {
        // First up with a closure we increment the internal reference
        // count. This ensures that the Rust closure environment won't
        // be deallocated while we're invoking it.
        state.cnt++;
        const a = state.a;
        state.a = 0;
        try {
            return f(a, state.b, ...args);
        } finally {
            if (--state.cnt === 0) {
                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
                CLOSURE_DTORS.unregister(state);
            } else {
                state.a = a;
            }
        }
    };
    real.original = state;
    CLOSURE_DTORS.register(real, state, state);
    return real;
}

function debugString(val) {
    // primitive types
    const type = typeof val;
    if (type == 'number' || type == 'boolean' || val == null) {
        return  `${val}`;
    }
    if (type == 'string') {
        return `"${val}"`;
    }
    if (type == 'symbol') {
        const description = val.description;
        if (description == null) {
            return 'Symbol';
        } else {
            return `Symbol(${description})`;
        }
    }
    if (type == 'function') {
        const name = val.name;
        if (typeof name == 'string' && name.length > 0) {
            return `Function(${name})`;
        } else {
            return 'Function';
        }
    }
    // objects
    if (Array.isArray(val)) {
        const length = val.length;
        let debug = '[';
        if (length > 0) {
            debug += debugString(val[0]);
        }
        for(let i = 1; i < length; i++) {
            debug += ', ' + debugString(val[i]);
        }
        debug += ']';
        return debug;
    }
    // Test for built-in
    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
    let className;
    if (builtInMatches && builtInMatches.length > 1) {
        className = builtInMatches[1];
    } else {
        // Failed to match the standard '[object ClassName]'
        return toString.call(val);
    }
    if (className == 'Object') {
        // we're a user defined class or Object
        // JSON.stringify avoids problems with cycles, and is generally much
        // easier than looping through ownProperties of `val`.
        try {
            return 'Object(' + JSON.stringify(val) + ')';
        } catch (_) {
            return 'Object';
        }
    }
    // errors
    if (val instanceof Error) {
        return `${val.name}: ${val.message}\n${val.stack}`;
    }
    // TODO we could test for more things here, like `Set`s and `Map`s.
    return className;
}

function takeFromExternrefTable0(idx) {
    const value = wasm.__wbindgen_export_4.get(idx);
    wasm.__externref_table_dealloc(idx);
    return value;
}

function passArrayJsValueToWasm0(array, malloc) {
    const ptr = malloc(array.length * 4, 4) >>> 0;
    for (let i = 0; i < array.length; i++) {
        const add = addToExternrefTable0(array[i]);
        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
    }
    WASM_VECTOR_LEN = array.length;
    return ptr;
}

function _assertClass(instance, klass) {
    if (!(instance instanceof klass)) {
        throw new Error(`expected instance of ${klass.name}`);
    }
}

let cachedFloat64ArrayMemory0 = null;

function getFloat64ArrayMemory0() {
    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
    }
    return cachedFloat64ArrayMemory0;
}

function passArrayF64ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 8, 8) >>> 0;
    getFloat64ArrayMemory0().set(arg, ptr / 8);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function getArrayF64FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
}

function initPanicHook() {
    wasm.initPanicHook();
}

function __wbg_adapter_62(arg0, arg1, arg2) {
    wasm.closure111_externref_shim(arg0, arg1, arg2);
}

function __wbg_adapter_65(arg0, arg1) {
    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h840edcdc529e167f(arg0, arg1);
}

function __wbg_adapter_120(arg0, arg1, arg2, arg3) {
    wasm.closure52_externref_shim(arg0, arg1, arg2, arg3);
}

/**
 * Configuration options for Cloudflare's image optimization feature:
 * <https://blog.cloudflare.com/introducing-polish-automatic-image-optimizati/>
 * @enum {0 | 1 | 2}
 */
const PolishConfig = Object.freeze({
    Off: 0, "0": "Off",
    Lossy: 1, "1": "Lossy",
    Lossless: 2, "2": "Lossless",
});
/**
 * @enum {0 | 1 | 2}
 */
const RequestRedirect = Object.freeze({
    Error: 0, "0": "Error",
    Follow: 1, "1": "Follow",
    Manual: 2, "2": "Manual",
});

const __wbindgen_enum_ReadableStreamType = ["bytes"];

const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];

const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];

const AnthropicAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_anthropicagent_free(ptr >>> 0, 1));

class AnthropicAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AnthropicAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_anthropicagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.anthropicagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        AnthropicAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.anthropicagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.anthropicagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.anthropicagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.anthropicagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const AnthropicCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_anthropiccompletionmodel_free(ptr >>> 0, 1));
/**
 * The Anthropic completions chat API.
 */
class AnthropicCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AnthropicCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_anthropiccompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.anthropiccompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        AnthropicCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.anthropiccompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const AssistantContentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_assistantcontent_free(ptr >>> 0, 1));

class AssistantContent {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(AssistantContent.prototype);
        obj.__wbg_ptr = ptr;
        AssistantContentFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AssistantContentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_assistantcontent_free(ptr, 0);
    }
    /**
     * @param {string} text
     * @returns {AssistantContent}
     */
    static text(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.assistantcontent_text(ptr0, len0);
        return AssistantContent.__wrap(ret);
    }
    /**
     * @param {string} id
     * @param {ToolFunction} _function
     * @returns {AssistantContent}
     */
    static tool_call(id, _function) {
        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        _assertClass(_function, ToolFunction);
        var ptr1 = _function.__destroy_into_raw();
        const ret = wasm.assistantcontent_tool_call(ptr0, len0, ptr1);
        return AssistantContent.__wrap(ret);
    }
    /**
     * @param {string} id
     * @param {string} call_id
     * @param {ToolFunction} _function
     * @returns {AssistantContent}
     */
    static tool_call_with_call_id(id, call_id, _function) {
        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len1 = WASM_VECTOR_LEN;
        _assertClass(_function, ToolFunction);
        var ptr2 = _function.__destroy_into_raw();
        const ret = wasm.assistantcontent_tool_call_with_call_id(ptr0, len0, ptr1, len1, ptr2);
        return AssistantContent.__wrap(ret);
    }
}

const CohereAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_cohereagent_free(ptr >>> 0, 1));

class CohereAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CohereAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_cohereagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.cohereagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        CohereAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.cohereagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.cohereagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.cohereagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.cohereagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const CohereCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_coherecompletionmodel_free(ptr >>> 0, 1));
/**
 * The Cohere Responses API, modelled as the Completions API.
 */
class CohereCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CohereCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_coherecompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.coherecompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        CohereCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.coherecompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const CohereEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_cohereembeddingmodel_free(ptr >>> 0, 1));

class CohereEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CohereEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_cohereembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.cohereembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        CohereEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.cohereembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.cohereembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const CompletionRequestFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_completionrequest_free(ptr >>> 0, 1));

class CompletionRequest {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CompletionRequestFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_completionrequest_free(ptr, 0);
    }
    /**
     * @param {CompletionOpts} opts
     */
    constructor(opts) {
        const ret = wasm.completionrequest_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        CompletionRequestFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
}

const DeepSeekAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_deepseekagent_free(ptr >>> 0, 1));

class DeepSeekAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DeepSeekAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_deepseekagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.deepseekagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        DeepSeekAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.deepseekagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.deepseekagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.deepseekagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.deepseekagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const DeepSeekCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_deepseekcompletionsmodel_free(ptr >>> 0, 1));
/**
 * The DeepSeek completions chat API.
 */
class DeepSeekCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DeepSeekCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_deepseekcompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.deepseekcompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        DeepSeekCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.deepseekcompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));

class Document {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(Document.prototype);
        obj.__wbg_ptr = ptr;
        DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DocumentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_document_free(ptr, 0);
    }
    /**
     * @param {string} id
     * @param {string} text
     */
    constructor(id, text) {
        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.document_new(ptr0, len0, ptr1, len1);
        this.__wbg_ptr = ret >>> 0;
        DocumentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {any} additional_props
     * @returns {Document}
     */
    setAdditionalProps(additional_props) {
        const ptr = this.__destroy_into_raw();
        const ret = wasm.document_setAdditionalProps(ptr, additional_props);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return Document.__wrap(ret[0]);
    }
}

const EmbeddingFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_embedding_free(ptr >>> 0, 1));

class Embedding {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(Embedding.prototype);
        obj.__wbg_ptr = ptr;
        EmbeddingFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        EmbeddingFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_embedding_free(ptr, 0);
    }
    /**
     * Create a new Embedding instance.
     * Generally not recommended as these are typically generated automatically from sending embedding requests to model providers.
     * @param {string} document
     * @param {Float64Array} embedding
     */
    constructor(document, embedding) {
        const ptr0 = passStringToWasm0(document, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayF64ToWasm0(embedding, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.embedding_new(ptr0, len0, ptr1, len1);
        this.__wbg_ptr = ret >>> 0;
        EmbeddingFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    get document() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.embedding_document(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {string} val
     */
    set document(val) {
        const ptr0 = passStringToWasm0(val, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        wasm.embedding_set_document(this.__wbg_ptr, ptr0, len0);
    }
    /**
     * @returns {Float64Array}
     */
    get vec() {
        const ret = wasm.embedding_vec(this.__wbg_ptr);
        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
        return v1;
    }
    /**
     * @param {Float64Array} vec
     */
    set vec(vec) {
        const ptr0 = passArrayF64ToWasm0(vec, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        wasm.embedding_set_vec(this.__wbg_ptr, ptr0, len0);
    }
}

const GaladrielAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_galadrielagent_free(ptr >>> 0, 1));

class GaladrielAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GaladrielAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_galadrielagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.galadrielagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GaladrielAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.galadrielagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.galadrielagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.galadrielagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.galadrielagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const GaladrielCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_galadrielcompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Galadriel completions chat API.
 */
class GaladrielCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GaladrielCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_galadrielcompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.galadrielcompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GaladrielCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.galadrielcompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const GeminiAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_geminiagent_free(ptr >>> 0, 1));

class GeminiAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeminiAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_geminiagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.geminiagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GeminiAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.geminiagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.geminiagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.geminiagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.geminiagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const GeminiCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_geminicompletionmodel_free(ptr >>> 0, 1));
/**
 * The Gemini Responses API, modelled as the Completions API.
 */
class GeminiCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeminiCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_geminicompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.geminicompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GeminiCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.geminicompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const GeminiEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_geminiembeddingmodel_free(ptr >>> 0, 1));

class GeminiEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeminiEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_geminiembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.geminiembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GeminiEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.geminiembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.geminiembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const GeminiTranscriptionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_geminitranscriptionmodel_free(ptr >>> 0, 1));

class GeminiTranscriptionModel {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(GeminiTranscriptionModel.prototype);
        obj.__wbg_ptr = ptr;
        GeminiTranscriptionModelFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeminiTranscriptionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_geminitranscriptionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     * @returns {GeminiTranscriptionModel}
     */
    static new(opts) {
        const ret = wasm.geminitranscriptionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return GeminiTranscriptionModel.__wrap(ret[0]);
    }
    /**
     * @param {TranscriptionOpts} opts
     * @returns {Promise<GeminiTranscriptionResponse>}
     */
    transcription(opts) {
        const ret = wasm.geminitranscriptionmodel_transcription(this.__wbg_ptr, opts);
        return ret;
    }
}

const GeminiTranscriptionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_geminitranscriptionresponse_free(ptr >>> 0, 1));

class GeminiTranscriptionResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(GeminiTranscriptionResponse.prototype);
        obj.__wbg_ptr = ptr;
        GeminiTranscriptionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeminiTranscriptionResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_geminitranscriptionresponse_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get text() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.geminitranscriptionresponse_text(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
}

const GroqAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_groqagent_free(ptr >>> 0, 1));

class GroqAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GroqAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_groqagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.groqagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GroqAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.groqagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.groqagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.groqagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.groqagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const GroqCompletionsCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_groqcompletionscompletionmodel_free(ptr >>> 0, 1));
/**
 * The Groq completions chat API.
 */
class GroqCompletionsCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GroqCompletionsCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_groqcompletionscompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.groqcompletionscompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        GroqCompletionsCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.groqcompletionscompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const GroqTranscriptionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_groqtranscriptionmodel_free(ptr >>> 0, 1));

class GroqTranscriptionModel {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(GroqTranscriptionModel.prototype);
        obj.__wbg_ptr = ptr;
        GroqTranscriptionModelFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GroqTranscriptionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_groqtranscriptionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     * @returns {GroqTranscriptionModel}
     */
    static new(opts) {
        const ret = wasm.groqtranscriptionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return GroqTranscriptionModel.__wrap(ret[0]);
    }
    /**
     * @param {TranscriptionOpts} opts
     * @returns {Promise<GroqTranscriptionResponse>}
     */
    transcription(opts) {
        const ret = wasm.groqtranscriptionmodel_transcription(this.__wbg_ptr, opts);
        return ret;
    }
}

const GroqTranscriptionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_groqtranscriptionresponse_free(ptr >>> 0, 1));

class GroqTranscriptionResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(GroqTranscriptionResponse.prototype);
        obj.__wbg_ptr = ptr;
        GroqTranscriptionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GroqTranscriptionResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_groqtranscriptionresponse_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get text() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.groqtranscriptionresponse_text(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
}

const HuggingFaceAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfaceagent_free(ptr >>> 0, 1));

class HuggingFaceAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfaceagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.huggingfaceagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HuggingFaceAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.huggingfaceagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.huggingfaceagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.huggingfaceagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.huggingfaceagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const HuggingFaceCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfacecompletionsmodel_free(ptr >>> 0, 1));
/**
 * The HuggingFace completions chat API.
 */
class HuggingFaceCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfacecompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.huggingfacecompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HuggingFaceCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.huggingfacecompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const HuggingFaceImageGenerationModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfaceimagegenerationmodel_free(ptr >>> 0, 1));

class HuggingFaceImageGenerationModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceImageGenerationModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfaceimagegenerationmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.huggingfaceimagegenerationmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HuggingFaceImageGenerationModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {ImageGenerationOpts} opts
     * @returns {Promise<HuggingFaceImageGenerationResponse>}
     */
    image_generation(opts) {
        const ret = wasm.huggingfaceimagegenerationmodel_image_generation(this.__wbg_ptr, opts);
        return ret;
    }
}

const HuggingFaceImageGenerationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfaceimagegenerationresponse_free(ptr >>> 0, 1));

class HuggingFaceImageGenerationResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HuggingFaceImageGenerationResponse.prototype);
        obj.__wbg_ptr = ptr;
        HuggingFaceImageGenerationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceImageGenerationResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfaceimagegenerationresponse_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    image_bytes() {
        const ret = wasm.huggingfaceimagegenerationresponse_image_bytes(this.__wbg_ptr);
        return ret;
    }
}

const HuggingFaceTranscriptionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfacetranscriptionmodel_free(ptr >>> 0, 1));

class HuggingFaceTranscriptionModel {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HuggingFaceTranscriptionModel.prototype);
        obj.__wbg_ptr = ptr;
        HuggingFaceTranscriptionModelFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceTranscriptionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfacetranscriptionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     * @returns {HuggingFaceTranscriptionModel}
     */
    static new(opts) {
        const ret = wasm.huggingfacetranscriptionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return HuggingFaceTranscriptionModel.__wrap(ret[0]);
    }
    /**
     * @param {TranscriptionOpts} opts
     * @returns {Promise<HuggingFaceTranscriptionResponse>}
     */
    transcription(opts) {
        const ret = wasm.huggingfacetranscriptionmodel_transcription(this.__wbg_ptr, opts);
        return ret;
    }
}

const HuggingFaceTranscriptionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_huggingfacetranscriptionresponse_free(ptr >>> 0, 1));

class HuggingFaceTranscriptionResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HuggingFaceTranscriptionResponse.prototype);
        obj.__wbg_ptr = ptr;
        HuggingFaceTranscriptionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HuggingFaceTranscriptionResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_huggingfacetranscriptionresponse_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get text() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.huggingfacetranscriptionresponse_text(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
}

const HyperbolicAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperbolicagent_free(ptr >>> 0, 1));

class HyperbolicAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperbolicagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.hyperbolicagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HyperbolicAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.hyperbolicagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.hyperbolicagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.hyperbolicagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.hyperbolicagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const HyperbolicAudioGenerationModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperbolicaudiogenerationmodel_free(ptr >>> 0, 1));

class HyperbolicAudioGenerationModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicAudioGenerationModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperbolicaudiogenerationmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.hyperbolicaudiogenerationmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HyperbolicAudioGenerationModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {AudioGenerationOpts} opts
     * @returns {Promise<HyperbolicAudioGenerationResponse>}
     */
    audio_generation(opts) {
        const ret = wasm.hyperbolicaudiogenerationmodel_audio_generation(this.__wbg_ptr, opts);
        return ret;
    }
}

const HyperbolicAudioGenerationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperbolicaudiogenerationresponse_free(ptr >>> 0, 1));
/**
 * Hyperbolic audio generation response.
 * Note that the inner type is actually base64.
 */
class HyperbolicAudioGenerationResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HyperbolicAudioGenerationResponse.prototype);
        obj.__wbg_ptr = ptr;
        HyperbolicAudioGenerationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicAudioGenerationResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperbolicaudiogenerationresponse_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    bytes() {
        const ptr = this.__destroy_into_raw();
        const ret = wasm.hyperbolicaudiogenerationresponse_bytes(ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return takeFromExternrefTable0(ret[0]);
    }
}

const HyperbolicCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperboliccompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Hyperbolic completions chat API.
 */
class HyperbolicCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperboliccompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.hyperboliccompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HyperbolicCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.hyperboliccompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const HyperbolicImageGenerationModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperbolicimagegenerationmodel_free(ptr >>> 0, 1));

class HyperbolicImageGenerationModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicImageGenerationModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperbolicimagegenerationmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.hyperbolicimagegenerationmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        HyperbolicImageGenerationModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {ImageGenerationOpts} opts
     * @returns {Promise<HyperbolicImageGenerationResponse>}
     */
    image_generation(opts) {
        const ret = wasm.hyperbolicimagegenerationmodel_image_generation(this.__wbg_ptr, opts);
        return ret;
    }
}

const HyperbolicImageGenerationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hyperbolicimagegenerationresponse_free(ptr >>> 0, 1));

class HyperbolicImageGenerationResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HyperbolicImageGenerationResponse.prototype);
        obj.__wbg_ptr = ptr;
        HyperbolicImageGenerationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HyperbolicImageGenerationResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hyperbolicimagegenerationresponse_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    image_bytes() {
        const ret = wasm.hyperbolicimagegenerationresponse_image_bytes(this.__wbg_ptr);
        return ret;
    }
}

const ImageGenerationRequestFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_imagegenerationrequest_free(ptr >>> 0, 1));

class ImageGenerationRequest {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ImageGenerationRequestFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_imagegenerationrequest_free(ptr, 0);
    }
}

const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));

class IntoUnderlyingByteSource {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        IntoUnderlyingByteSourceFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
    }
    /**
     * @returns {ReadableStreamType}
     */
    get type() {
        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
        return __wbindgen_enum_ReadableStreamType[ret];
    }
    /**
     * @returns {number}
     */
    get autoAllocateChunkSize() {
        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @param {ReadableByteStreamController} controller
     */
    start(controller) {
        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
    }
    /**
     * @param {ReadableByteStreamController} controller
     * @returns {Promise<any>}
     */
    pull(controller) {
        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
        return ret;
    }
    cancel() {
        const ptr = this.__destroy_into_raw();
        wasm.intounderlyingbytesource_cancel(ptr);
    }
}

const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));

class IntoUnderlyingSink {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        IntoUnderlyingSinkFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_intounderlyingsink_free(ptr, 0);
    }
    /**
     * @param {any} chunk
     * @returns {Promise<any>}
     */
    write(chunk) {
        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
        return ret;
    }
    /**
     * @returns {Promise<any>}
     */
    close() {
        const ptr = this.__destroy_into_raw();
        const ret = wasm.intounderlyingsink_close(ptr);
        return ret;
    }
    /**
     * @param {any} reason
     * @returns {Promise<any>}
     */
    abort(reason) {
        const ptr = this.__destroy_into_raw();
        const ret = wasm.intounderlyingsink_abort(ptr, reason);
        return ret;
    }
}

const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));

class IntoUnderlyingSource {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(IntoUnderlyingSource.prototype);
        obj.__wbg_ptr = ptr;
        IntoUnderlyingSourceFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        IntoUnderlyingSourceFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_intounderlyingsource_free(ptr, 0);
    }
    /**
     * @param {ReadableStreamDefaultController} controller
     * @returns {Promise<any>}
     */
    pull(controller) {
        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
        return ret;
    }
    cancel() {
        const ptr = this.__destroy_into_raw();
        wasm.intounderlyingsource_cancel(ptr);
    }
}

const JsToolFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_jstool_free(ptr >>> 0, 1));
/**
 * A tool that can take a JavaScript function.
 * Generally speaking, any class that implements the `JsToolObject` TS interface will work when creating this.
 */
class JsTool {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        JsToolFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_jstool_free(ptr, 0);
    }
    /**
     * @param {any} tool
     */
    constructor(tool) {
        const ret = wasm.jstool_new(tool);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        JsToolFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
}

const JsVectorStoreFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_jsvectorstore_free(ptr >>> 0, 1));

class JsVectorStore {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        JsVectorStoreFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_jsvectorstore_free(ptr, 0);
    }
    /**
     * @param {any} shim
     */
    constructor(shim) {
        const ret = wasm.jsvectorstore_new(shim);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        JsVectorStoreFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
}

const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));

class Message {

    static __unwrap(jsValue) {
        if (!(jsValue instanceof Message)) {
            return 0;
        }
        return jsValue.__destroy_into_raw();
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MessageFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_message_free(ptr, 0);
    }
}

const MinifyConfigFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_minifyconfig_free(ptr >>> 0, 1));
/**
 * Configuration options for Cloudflare's minification features:
 * <https://www.cloudflare.com/website-optimization/>
 */
class MinifyConfig {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MinifyConfigFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_minifyconfig_free(ptr, 0);
    }
    /**
     * @returns {boolean}
     */
    get js() {
        const ret = wasm.__wbg_get_minifyconfig_js(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @param {boolean} arg0
     */
    set js(arg0) {
        wasm.__wbg_set_minifyconfig_js(this.__wbg_ptr, arg0);
    }
    /**
     * @returns {boolean}
     */
    get html() {
        const ret = wasm.__wbg_get_minifyconfig_html(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @param {boolean} arg0
     */
    set html(arg0) {
        wasm.__wbg_set_minifyconfig_html(this.__wbg_ptr, arg0);
    }
    /**
     * @returns {boolean}
     */
    get css() {
        const ret = wasm.__wbg_get_minifyconfig_css(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @param {boolean} arg0
     */
    set css(arg0) {
        wasm.__wbg_set_minifyconfig_css(this.__wbg_ptr, arg0);
    }
}

const MiraAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_miraagent_free(ptr >>> 0, 1));

class MiraAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MiraAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_miraagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.miraagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MiraAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.miraagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.miraagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.miraagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.miraagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const MiraCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_miracompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Mira completions chat API.
 */
class MiraCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MiraCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_miracompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.miracompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MiraCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.miracompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const MistralAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_mistralagent_free(ptr >>> 0, 1));

class MistralAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MistralAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_mistralagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.mistralagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MistralAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.mistralagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.mistralagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.mistralagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.mistralagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const MistralCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_mistralcompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Mistral completions chat API.
 */
class MistralCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MistralCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_mistralcompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.mistralcompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MistralCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.mistralcompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const MistralEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_mistralembeddingmodel_free(ptr >>> 0, 1));

class MistralEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MistralEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_mistralembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.mistralembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MistralEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.mistralembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.mistralembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const MoonshotAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_moonshotagent_free(ptr >>> 0, 1));

class MoonshotAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MoonshotAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_moonshotagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.moonshotagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MoonshotAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.moonshotagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.moonshotagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.moonshotagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.moonshotagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const MoonshotCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_moonshotcompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Moonshot completions chat API.
 */
class MoonshotCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MoonshotCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_moonshotcompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.moonshotcompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        MoonshotCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.moonshotcompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const OllamaAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ollamaagent_free(ptr >>> 0, 1));

class OllamaAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OllamaAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ollamaagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.ollamaagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OllamaAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.ollamaagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.ollamaagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.ollamaagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.ollamaagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const OllamaCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ollamacompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Ollama completions chat API.
 */
class OllamaCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OllamaCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ollamacompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.ollamacompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OllamaCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.ollamacompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAIAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiagent_free(ptr >>> 0, 1));

class OpenAIAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openaiagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAIAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openaiagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openaiagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openaiagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.openaiagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const OpenAIAudioGenerationModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiaudiogenerationmodel_free(ptr >>> 0, 1));

class OpenAIAudioGenerationModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIAudioGenerationModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiaudiogenerationmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openaiaudiogenerationmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAIAudioGenerationModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {AudioGenerationOpts} opts
     * @returns {Promise<OpenAIAudioGenerationResponse>}
     */
    audio_generation(opts) {
        const ret = wasm.openaiaudiogenerationmodel_audio_generation(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAIAudioGenerationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiaudiogenerationresponse_free(ptr >>> 0, 1));

class OpenAIAudioGenerationResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(OpenAIAudioGenerationResponse.prototype);
        obj.__wbg_ptr = ptr;
        OpenAIAudioGenerationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIAudioGenerationResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiaudiogenerationresponse_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    bytes() {
        const ret = wasm.openaiaudiogenerationresponse_bytes(this.__wbg_ptr);
        return ret;
    }
}

const OpenAICompletionsCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaicompletionscompletionmodel_free(ptr >>> 0, 1));
/**
 * The OpenAI completions chat API.
 */
class OpenAICompletionsCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAICompletionsCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaicompletionscompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openaicompletionscompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAICompletionsCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.openaicompletionscompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAIEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiembeddingmodel_free(ptr >>> 0, 1));

class OpenAIEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openaiembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAIEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openaiembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.openaiembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const OpenAIImageGenerationModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiimagegenerationmodel_free(ptr >>> 0, 1));

class OpenAIImageGenerationModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIImageGenerationModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiimagegenerationmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openaiimagegenerationmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAIImageGenerationModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {ImageGenerationOpts} opts
     * @returns {Promise<OpenAIImageGenerationResponse>}
     */
    image_generation(opts) {
        const ret = wasm.openaiimagegenerationmodel_image_generation(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAIImageGenerationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaiimagegenerationresponse_free(ptr >>> 0, 1));

class OpenAIImageGenerationResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(OpenAIImageGenerationResponse.prototype);
        obj.__wbg_ptr = ptr;
        OpenAIImageGenerationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIImageGenerationResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaiimagegenerationresponse_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    image_bytes() {
        const ret = wasm.openaiimagegenerationresponse_image_bytes(this.__wbg_ptr);
        return ret;
    }
}

const OpenAIResponsesCompletionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openairesponsescompletionmodel_free(ptr >>> 0, 1));
/**
 * The OpenAI Responses API, modelled as the Completions API.
 */
class OpenAIResponsesCompletionModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAIResponsesCompletionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openairesponsescompletionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openairesponsescompletionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenAIResponsesCompletionModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.openairesponsescompletionmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAITranscriptionModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaitranscriptionmodel_free(ptr >>> 0, 1));

class OpenAITranscriptionModel {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(OpenAITranscriptionModel.prototype);
        obj.__wbg_ptr = ptr;
        OpenAITranscriptionModelFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAITranscriptionModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaitranscriptionmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     * @returns {OpenAITranscriptionModel}
     */
    static new(opts) {
        const ret = wasm.openaitranscriptionmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return OpenAITranscriptionModel.__wrap(ret[0]);
    }
    /**
     * @param {TranscriptionOpts} opts
     * @returns {Promise<OpenAITranscriptionResponse>}
     */
    transcription(opts) {
        const ret = wasm.openaitranscriptionmodel_transcription(this.__wbg_ptr, opts);
        return ret;
    }
}

const OpenAITranscriptionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openaitranscriptionresponse_free(ptr >>> 0, 1));

class OpenAITranscriptionResponse {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(OpenAITranscriptionResponse.prototype);
        obj.__wbg_ptr = ptr;
        OpenAITranscriptionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenAITranscriptionResponseFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openaitranscriptionresponse_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get text() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.openaitranscriptionresponse_text(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
}

const OpenRouterAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openrouteragent_free(ptr >>> 0, 1));

class OpenRouterAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenRouterAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openrouteragent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openrouteragent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenRouterAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openrouteragent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openrouteragent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.openrouteragent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.openrouteragent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const OpenRouterCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_openroutercompletionsmodel_free(ptr >>> 0, 1));
/**
 * The OpenRouter completions chat API.
 */
class OpenRouterCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OpenRouterCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_openroutercompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.openroutercompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        OpenRouterCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.openroutercompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const PerplexityAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_perplexityagent_free(ptr >>> 0, 1));

class PerplexityAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PerplexityAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_perplexityagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.perplexityagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        PerplexityAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.perplexityagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.perplexityagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.perplexityagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.perplexityagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const PerplexityCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_perplexitycompletionsmodel_free(ptr >>> 0, 1));
/**
 * The Perplexity completions chat API.
 */
class PerplexityCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PerplexityCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_perplexitycompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.perplexitycompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        PerplexityCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.perplexitycompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const R2RangeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_r2range_free(ptr >>> 0, 1));

class R2Range {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        R2RangeFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_r2range_free(ptr, 0);
    }
    /**
     * @returns {number | undefined}
     */
    get offset() {
        const ret = wasm.__wbg_get_r2range_offset(this.__wbg_ptr);
        return ret[0] === 0 ? undefined : ret[1];
    }
    /**
     * @param {number | null} [arg0]
     */
    set offset(arg0) {
        wasm.__wbg_set_r2range_offset(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
    }
    /**
     * @returns {number | undefined}
     */
    get length() {
        const ret = wasm.__wbg_get_r2range_length(this.__wbg_ptr);
        return ret[0] === 0 ? undefined : ret[1];
    }
    /**
     * @param {number | null} [arg0]
     */
    set length(arg0) {
        wasm.__wbg_set_r2range_length(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
    }
    /**
     * @returns {number | undefined}
     */
    get suffix() {
        const ret = wasm.__wbg_get_r2range_suffix(this.__wbg_ptr);
        return ret[0] === 0 ? undefined : ret[1];
    }
    /**
     * @param {number | null} [arg0]
     */
    set suffix(arg0) {
        wasm.__wbg_set_r2range_suffix(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
    }
}

const TogetherAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_togetheragent_free(ptr >>> 0, 1));

class TogetherAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        TogetherAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_togetheragent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.togetheragent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        TogetherAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.togetheragent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.togetheragent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.togetheragent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.togetheragent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const TogetherCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_togethercompletionsmodel_free(ptr >>> 0, 1));
/**
 * The TogetherAI completions chat API.
 */
class TogetherCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        TogetherCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_togethercompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.togethercompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        TogetherCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.togethercompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

const TogetherEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_togetherembeddingmodel_free(ptr >>> 0, 1));

class TogetherEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        TogetherEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_togetherembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.togetherembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        TogetherEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.togetherembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.togetherembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const ToolDefinitionFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_tooldefinition_free(ptr >>> 0, 1));

class ToolDefinition {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ToolDefinitionFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_tooldefinition_free(ptr, 0);
    }
    /**
     * @param {any} args
     */
    constructor(args) {
        const ret = wasm.tooldefinition_new(args);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        ToolDefinitionFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
}

const ToolFunctionFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_toolfunction_free(ptr >>> 0, 1));

class ToolFunction {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ToolFunctionFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_toolfunction_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    name() {
        let deferred1_0;
        let deferred1_1;
        try {
            const ret = wasm.toolfunction_name(this.__wbg_ptr);
            deferred1_0 = ret[0];
            deferred1_1 = ret[1];
            return getStringFromWasm0(ret[0], ret[1]);
        } finally {
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {any}
     */
    args() {
        const ret = wasm.toolfunction_args(this.__wbg_ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return takeFromExternrefTable0(ret[0]);
    }
}

const TranscriptionRequestFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_transcriptionrequest_free(ptr >>> 0, 1));

class TranscriptionRequest {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        TranscriptionRequestFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_transcriptionrequest_free(ptr, 0);
    }
}

const VoyageAIEmbeddingModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_voyageaiembeddingmodel_free(ptr >>> 0, 1));

class VoyageAIEmbeddingModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        VoyageAIEmbeddingModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_voyageaiembeddingmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.voyageaiembeddingmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        VoyageAIEmbeddingModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} text
     * @returns {Promise<Embedding>}
     */
    embedText(text) {
        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.voyageaiembeddingmodel_embedText(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {Iterable<string>} iter
     * @returns {Promise<Embedding[]>}
     */
    embedTexts(iter) {
        const ret = wasm.voyageaiembeddingmodel_embedTexts(this.__wbg_ptr, iter);
        return ret;
    }
}

const XaiAgentFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_xaiagent_free(ptr >>> 0, 1));

class XaiAgent {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        XaiAgentFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_xaiagent_free(ptr, 0);
    }
    /**
     * @param {AgentOpts} opts
     */
    constructor(opts) {
        const ret = wasm.xaiagent_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        XaiAgentFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<string>}
     */
    prompt(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.xaiagent_prompt(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @returns {Promise<ReadableStream>}
     */
    prompt_stream(prompt) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.xaiagent_prompt_stream(this.__wbg_ptr, ptr0, len0);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {number} turns
     * @returns {Promise<string>}
     */
    prompt_multi_turn(prompt, turns) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.xaiagent_prompt_multi_turn(this.__wbg_ptr, ptr0, len0, turns);
        return ret;
    }
    /**
     * @param {string} prompt
     * @param {Message[]} messages
     * @returns {Promise<string>}
     */
    chat(prompt, messages) {
        const ptr0 = passStringToWasm0(prompt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_malloc);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.xaiagent_chat(this.__wbg_ptr, ptr0, len0, ptr1, len1);
        return ret;
    }
}

const XaiCompletionsModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_xaicompletionsmodel_free(ptr >>> 0, 1));
/**
 * The xAI completions chat API.
 */
class XaiCompletionsModel {

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        XaiCompletionsModelFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_xaicompletionsmodel_free(ptr, 0);
    }
    /**
     * @param {ModelOpts} opts
     */
    constructor(opts) {
        const ret = wasm.xaicompletionsmodel_new(opts);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        this.__wbg_ptr = ret[0] >>> 0;
        XaiCompletionsModelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {CompletionOpts} opts
     * @returns {Promise<any>}
     */
    completion(opts) {
        const ret = wasm.xaicompletionsmodel_completion(this.__wbg_ptr, opts);
        return ret;
    }
}

function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
    const ret = String(arg1);
    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbg_abort_410ec47a64ac6117(arg0, arg1) {
    arg0.abort(arg1);
}
function __wbg_abort_775ef1d17fc65868(arg0) {
    arg0.abort();
}
function __wbg_append_299d5d48292c0495() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
    arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
}, arguments) }
function __wbg_append_8c7dd8d641a5f01b() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
    arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
}, arguments) }
function __wbg_append_b2d1fc16de2a0e81() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
    arg0.append(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5));
}, arguments) }
function __wbg_append_b44785ebeb668479() { return handleError(function (arg0, arg1, arg2, arg3) {
    arg0.append(getStringFromWasm0(arg1, arg2), arg3);
}, arguments) }
function __wbg_arrayBuffer_d1b44c4390db422f() { return handleError(function (arg0) {
    const ret = arg0.arrayBuffer();
    return ret;
}, arguments) }
function __wbg_body_0b8fd1fe671660df(arg0) {
    const ret = arg0.body;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_buffer_09165b52af8c5237(arg0) {
    const ret = arg0.buffer;
    return ret;
}
function __wbg_buffer_609cc3eee51ed158(arg0) {
    const ret = arg0.buffer;
    return ret;
}
function __wbg_byobRequest_77d9adf63337edfb(arg0) {
    const ret = arg0.byobRequest;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_byteLength_e674b853d9c77e1d(arg0) {
    const ret = arg0.byteLength;
    return ret;
}
function __wbg_byteOffset_fd862df290ef848d(arg0) {
    const ret = arg0.byteOffset;
    return ret;
}
function __wbg_call_672a4d21634d4a24() { return handleError(function (arg0, arg1) {
    const ret = arg0.call(arg1);
    return ret;
}, arguments) }
function __wbg_call_7cccdd69e0791ae2() { return handleError(function (arg0, arg1, arg2) {
    const ret = arg0.call(arg1, arg2);
    return ret;
}, arguments) }
function __wbg_cancel_8a308660caa6cadf(arg0) {
    const ret = arg0.cancel();
    return ret;
}
function __wbg_catch_a6e601879b2610e9(arg0, arg1) {
    const ret = arg0.catch(arg1);
    return ret;
}
function __wbg_clearTimeout_b1115618e821c3b2(arg0) {
    const ret = clearTimeout(arg0);
    return ret;
}
function __wbg_close_304cc1fef3466669() { return handleError(function (arg0) {
    arg0.close();
}, arguments) }
function __wbg_close_5ce03e29be453811() { return handleError(function (arg0) {
    arg0.close();
}, arguments) }
function __wbg_done_769e5ede4b31c67b(arg0) {
    const ret = arg0.done;
    return ret;
}
function __wbg_embedding_new(arg0) {
    const ret = Embedding.__wrap(arg0);
    return ret;
}
function __wbg_enqueue_bb16ba72f537dc9e() { return handleError(function (arg0, arg1) {
    arg0.enqueue(arg1);
}, arguments) }
function __wbg_entries_3265d4158b33e5dc(arg0) {
    const ret = Object.entries(arg0);
    return ret;
}
function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
    let deferred0_0;
    let deferred0_1;
    try {
        deferred0_0 = arg0;
        deferred0_1 = arg1;
        console.error(getStringFromWasm0(arg0, arg1));
    } finally {
        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
    }
}
function __wbg_fetch_3afbdcc7ddbf16fe(arg0) {
    const ret = fetch(arg0);
    return ret;
}
function __wbg_fetch_509096533071c657(arg0, arg1) {
    const ret = arg0.fetch(arg1);
    return ret;
}
function __wbg_from_2a5d3e218e67aa85(arg0) {
    const ret = Array.from(arg0);
    return ret;
}
function __wbg_geminitranscriptionresponse_new(arg0) {
    const ret = GeminiTranscriptionResponse.__wrap(arg0);
    return ret;
}
function __wbg_getReader_48e00749fe3f6089() { return handleError(function (arg0) {
    const ret = arg0.getReader();
    return ret;
}, arguments) }
function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) {
    const ret = Reflect.get(arg0, arg1);
    return ret;
}, arguments) }
function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
    const ret = arg0[arg1 >>> 0];
    return ret;
}
function __wbg_getdone_d47073731acd3e74(arg0) {
    const ret = arg0.done;
    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
}
function __wbg_getvalue_009dcd63692bee1f(arg0) {
    const ret = arg0.value;
    return ret;
}
function __wbg_getwithrefkey_1dc361bd10053bfe(arg0, arg1) {
    const ret = arg0[arg1];
    return ret;
}
function __wbg_groqtranscriptionresponse_new(arg0) {
    const ret = GroqTranscriptionResponse.__wrap(arg0);
    return ret;
}
function __wbg_has_a5ea9117f258a0ec() { return handleError(function (arg0, arg1) {
    const ret = Reflect.has(arg0, arg1);
    return ret;
}, arguments) }
function __wbg_headers_9cb51cfd2ac780a4(arg0) {
    const ret = arg0.headers;
    return ret;
}
function __wbg_huggingfaceimagegenerationresponse_new(arg0) {
    const ret = HuggingFaceImageGenerationResponse.__wrap(arg0);
    return ret;
}
function __wbg_huggingfacetranscriptionresponse_new(arg0) {
    const ret = HuggingFaceTranscriptionResponse.__wrap(arg0);
    return ret;
}
function __wbg_hyperbolicaudiogenerationresponse_new(arg0) {
    const ret = HyperbolicAudioGenerationResponse.__wrap(arg0);
    return ret;
}
function __wbg_hyperbolicimagegenerationresponse_new(arg0) {
    const ret = HyperbolicImageGenerationResponse.__wrap(arg0);
    return ret;
}
function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
    let result;
    try {
        result = arg0 instanceof ArrayBuffer;
    } catch (_) {
        result = false;
    }
    const ret = result;
    return ret;
}
function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
    let result;
    try {
        result = arg0 instanceof Map;
    } catch (_) {
        result = false;
    }
    const ret = result;
    return ret;
}
function __wbg_instanceof_Promise_935168b8f4b49db3(arg0) {
    let result;
    try {
        result = arg0 instanceof Promise;
    } catch (_) {
        result = false;
    }
    const ret = result;
    return ret;
}
function __wbg_instanceof_Response_f2cc20d9f7dfd644(arg0) {
    let result;
    try {
        result = arg0 instanceof Response;
    } catch (_) {
        result = false;
    }
    const ret = result;
    return ret;
}
function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
    let result;
    try {
        result = arg0 instanceof Uint8Array;
    } catch (_) {
        result = false;
    }
    const ret = result;
    return ret;
}
function __wbg_isArray_a1eab7e0d067391b(arg0) {
    const ret = Array.isArray(arg0);
    return ret;
}
function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) {
    const ret = Number.isSafeInteger(arg0);
    return ret;
}
function __wbg_iterator_9a24c88df860dc65() {
    const ret = Symbol.iterator;
    return ret;
}
function __wbg_length_a446193dc22c12f8(arg0) {
    const ret = arg0.length;
    return ret;
}
function __wbg_length_e2d2a49132c1b256(arg0) {
    const ret = arg0.length;
    return ret;
}
function __wbg_message_unwrap(arg0) {
    const ret = Message.__unwrap(arg0);
    return ret;
}
function __wbg_name_a0a40e66e4d7971f(arg0, arg1) {
    const ret = arg1.name();
    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbg_new_018dcc2d6c8c2f6a() { return handleError(function () {
    const ret = new Headers();
    return ret;
}, arguments) }
function __wbg_new_23a2665fac83c611(arg0, arg1) {
    try {
        var state0 = {a: arg0, b: arg1};
        var cb0 = (arg0, arg1) => {
            const a = state0.a;
            state0.a = 0;
            try {
                return __wbg_adapter_120(a, state0.b, arg0, arg1);
            } finally {
                state0.a = a;
            }
        };
        const ret = new Promise(cb0);
        return ret;
    } finally {
        state0.a = state0.b = 0;
    }
}
function __wbg_new_405e22f390576ce2() {
    const ret = new Object();
    return ret;
}
function __wbg_new_5e0be73521bc8c17() {
    const ret = new Map();
    return ret;
}
function __wbg_new_78feb108b6472713() {
    const ret = new Array();
    return ret;
}
function __wbg_new_8a6f238a6ece86ea() {
    const ret = new Error();
    return ret;
}
function __wbg_new_9fd39a253424609a() { return handleError(function () {
    const ret = new FormData();
    return ret;
}, arguments) }
function __wbg_new_a12002a7f91c75be(arg0) {
    const ret = new Uint8Array(arg0);
    return ret;
}
function __wbg_new_c68d7209be747379(arg0, arg1) {
    const ret = new Error(getStringFromWasm0(arg0, arg1));
    return ret;
}
function __wbg_new_e25e5aab09ff45db() { return handleError(function () {
    const ret = new AbortController();
    return ret;
}, arguments) }
function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) {
    const ret = new Function(getStringFromWasm0(arg0, arg1));
    return ret;
}
function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
    return ret;
}
function __wbg_newwithintounderlyingsource_b47f6a6a596a7f24(arg0, arg1) {
    const ret = new ReadableStream(IntoUnderlyingSource.__wrap(arg0), arg1);
    return ret;
}
function __wbg_newwithstrandinit_06c535e0a867c635() { return handleError(function (arg0, arg1, arg2) {
    const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
    return ret;
}, arguments) }
function __wbg_newwithu8arraysequenceandoptions_068570c487f69127() { return handleError(function (arg0, arg1) {
    const ret = new Blob(arg0, arg1);
    return ret;
}, arguments) }
function __wbg_next_25feadfc0913fea9(arg0) {
    const ret = arg0.next;
    return ret;
}
function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg0) {
    const ret = arg0.next();
    return ret;
}, arguments) }
function __wbg_openaiaudiogenerationresponse_new(arg0) {
    const ret = OpenAIAudioGenerationResponse.__wrap(arg0);
    return ret;
}
function __wbg_openaiimagegenerationresponse_new(arg0) {
    const ret = OpenAIImageGenerationResponse.__wrap(arg0);
    return ret;
}
function __wbg_openaitranscriptionresponse_new(arg0) {
    const ret = OpenAITranscriptionResponse.__wrap(arg0);
    return ret;
}
function __wbg_push_737cfc8c1432c2c6(arg0, arg1) {
    const ret = arg0.push(arg1);
    return ret;
}
function __wbg_queueMicrotask_97d92b4fcc8a61c5(arg0) {
    queueMicrotask(arg0);
}
function __wbg_queueMicrotask_d3219def82552485(arg0) {
    const ret = arg0.queueMicrotask;
    return ret;
}
function __wbg_read_a2434af1186cb56c(arg0) {
    const ret = arg0.read();
    return ret;
}
function __wbg_releaseLock_091899af97991d2e(arg0) {
    arg0.releaseLock();
}
function __wbg_resolve_4851785c9c5f573d(arg0) {
    const ret = Promise.resolve(arg0);
    return ret;
}
function __wbg_respond_1f279fa9f8edcb1c() { return handleError(function (arg0, arg1) {
    arg0.respond(arg1 >>> 0);
}, arguments) }
function __wbg_setTimeout_ca12ead8b48245e2(arg0, arg1) {
    const ret = setTimeout(arg0, arg1);
    return ret;
}
function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
    arg0[arg1 >>> 0] = arg2;
}
function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
    arg0[arg1] = arg2;
}
function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
    arg0.set(arg1, arg2 >>> 0);
}
function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) {
    const ret = arg0.set(arg1, arg2);
    return ret;
}
function __wbg_setbody_5923b78a95eedf29(arg0, arg1) {
    arg0.body = arg1;
}
function __wbg_setcredentials_c3a22f1cd105a2c6(arg0, arg1) {
    arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
}
function __wbg_setheaders_834c0bdb6a8949ad(arg0, arg1) {
    arg0.headers = arg1;
}
function __wbg_sethighwatermark_793c99c89830c8e9(arg0, arg1) {
    arg0.highWaterMark = arg1;
}
function __wbg_setmethod_3c5280fe5d890842(arg0, arg1, arg2) {
    arg0.method = getStringFromWasm0(arg1, arg2);
}
function __wbg_setmode_5dc300b865044b65(arg0, arg1) {
    arg0.mode = __wbindgen_enum_RequestMode[arg1];
}
function __wbg_setsignal_75b21ef3a81de905(arg0, arg1) {
    arg0.signal = arg1;
}
function __wbg_settype_39ed370d3edd403c(arg0, arg1, arg2) {
    arg0.type = getStringFromWasm0(arg1, arg2);
}
function __wbg_signal_aaf9ad74119f20a4(arg0) {
    const ret = arg0.signal;
    return ret;
}
function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
    const ret = arg1.stack;
    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbg_static_accessor_GLOBAL_88a902d13a557d07() {
    const ret = typeof global === 'undefined' ? null : global;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() {
    const ret = typeof globalThis === 'undefined' ? null : globalThis;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_static_accessor_SELF_37c5d418e4bf5819() {
    const ret = typeof self === 'undefined' ? null : self;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_static_accessor_WINDOW_5de37043a91a9c40() {
    const ret = typeof window === 'undefined' ? null : window;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbg_status_f6360336ca686bf0(arg0) {
    const ret = arg0.status;
    return ret;
}
function __wbg_stringify_f7ed6987935b4a24() { return handleError(function (arg0) {
    const ret = JSON.stringify(arg0);
    return ret;
}, arguments) }
function __wbg_text_7805bea50de2af49() { return handleError(function (arg0) {
    const ret = arg0.text();
    return ret;
}, arguments) }
function __wbg_then_44b73946d2fb3e7d(arg0, arg1) {
    const ret = arg0.then(arg1);
    return ret;
}
function __wbg_then_48b406749878a531(arg0, arg1, arg2) {
    const ret = arg0.then(arg1, arg2);
    return ret;
}
function __wbg_url_ae10c34ca209681d(arg0, arg1) {
    const ret = arg1.url;
    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbg_value_cd1ffa7b1ab794f1(arg0) {
    const ret = arg0.value;
    return ret;
}
function __wbg_view_fd8a56e8983f448d(arg0) {
    const ret = arg0.view;
    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
}
function __wbindgen_array_new() {
    const ret = [];
    return ret;
}
function __wbindgen_array_push(arg0, arg1) {
    arg0.push(arg1);
}
function __wbindgen_as_number(arg0) {
    const ret = +arg0;
    return ret;
}
function __wbindgen_bigint_from_i64(arg0) {
    const ret = arg0;
    return ret;
}
function __wbindgen_bigint_from_u64(arg0) {
    const ret = BigInt.asUintN(64, arg0);
    return ret;
}
function __wbindgen_bigint_get_as_i64(arg0, arg1) {
    const v = arg1;
    const ret = typeof(v) === 'bigint' ? v : undefined;
    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
}
function __wbindgen_boolean_get(arg0) {
    const v = arg0;
    const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
    return ret;
}
function __wbindgen_cb_drop(arg0) {
    const obj = arg0.original;
    if (obj.cnt-- == 1) {
        obj.a = 0;
        return true;
    }
    const ret = false;
    return ret;
}
function __wbindgen_closure_wrapper2099(arg0, arg1, arg2) {
    const ret = makeMutClosure(arg0, arg1, 112, __wbg_adapter_62);
    return ret;
}
function __wbindgen_closure_wrapper2121(arg0, arg1, arg2) {
    const ret = makeMutClosure(arg0, arg1, 66, __wbg_adapter_65);
    return ret;
}
function __wbindgen_debug_string(arg0, arg1) {
    const ret = debugString(arg1);
    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbindgen_error_new(arg0, arg1) {
    const ret = new Error(getStringFromWasm0(arg0, arg1));
    return ret;
}
function __wbindgen_in(arg0, arg1) {
    const ret = arg0 in arg1;
    return ret;
}
function __wbindgen_init_externref_table() {
    const table = wasm.__wbindgen_export_4;
    const offset = table.grow(4);
    table.set(0, undefined);
    table.set(offset + 0, undefined);
    table.set(offset + 1, null);
    table.set(offset + 2, true);
    table.set(offset + 3, false);
}
function __wbindgen_is_array(arg0) {
    const ret = Array.isArray(arg0);
    return ret;
}
function __wbindgen_is_bigint(arg0) {
    const ret = typeof(arg0) === 'bigint';
    return ret;
}
function __wbindgen_is_function(arg0) {
    const ret = typeof(arg0) === 'function';
    return ret;
}
function __wbindgen_is_null(arg0) {
    const ret = arg0 === null;
    return ret;
}
function __wbindgen_is_object(arg0) {
    const val = arg0;
    const ret = typeof(val) === 'object' && val !== null;
    return ret;
}
function __wbindgen_is_string(arg0) {
    const ret = typeof(arg0) === 'string';
    return ret;
}
function __wbindgen_is_undefined(arg0) {
    const ret = arg0 === undefined;
    return ret;
}
function __wbindgen_jsval_eq(arg0, arg1) {
    const ret = arg0 === arg1;
    return ret;
}
function __wbindgen_jsval_loose_eq(arg0, arg1) {
    const ret = arg0 == arg1;
    return ret;
}
function __wbindgen_memory() {
    const ret = wasm.memory;
    return ret;
}
function __wbindgen_number_get(arg0, arg1) {
    const obj = arg1;
    const ret = typeof(obj) === 'number' ? obj : undefined;
    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
}
function __wbindgen_number_new(arg0) {
    const ret = arg0;
    return ret;
}
function __wbindgen_string_get(arg0, arg1) {
    const obj = arg1;
    const ret = typeof(obj) === 'string' ? obj : undefined;
    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len1 = WASM_VECTOR_LEN;
    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
}
function __wbindgen_string_new(arg0, arg1) {
    const ret = getStringFromWasm0(arg0, arg1);
    return ret;
}
function __wbindgen_throw(arg0, arg1) {
    throw new Error(getStringFromWasm0(arg0, arg1));
}
function __wbindgen_typeof(arg0) {
    const ret = typeof arg0;
    return ret;
}

export { AnthropicAgent, AnthropicCompletionModel, AssistantContent, CohereAgent, CohereCompletionModel, CohereEmbeddingModel, CompletionRequest, DeepSeekAgent, DeepSeekCompletionsModel, Document, Embedding, GaladrielAgent, GaladrielCompletionsModel, GeminiAgent, GeminiCompletionModel, GeminiEmbeddingModel, GeminiTranscriptionModel, GeminiTranscriptionResponse, GroqAgent, GroqCompletionsCompletionModel, GroqTranscriptionModel, GroqTranscriptionResponse, HuggingFaceAgent, HuggingFaceCompletionsModel, HuggingFaceImageGenerationModel, HuggingFaceImageGenerationResponse, HuggingFaceTranscriptionModel, HuggingFaceTranscriptionResponse, HyperbolicAgent, HyperbolicAudioGenerationModel, HyperbolicAudioGenerationResponse, HyperbolicCompletionsModel, HyperbolicImageGenerationModel, HyperbolicImageGenerationResponse, ImageGenerationRequest, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsTool, JsVectorStore, Message, MinifyConfig, MiraAgent, MiraCompletionsModel, MistralAgent, MistralCompletionsModel, MistralEmbeddingModel, MoonshotAgent, MoonshotCompletionsModel, OllamaAgent, OllamaCompletionsModel, OpenAIAgent, OpenAIAudioGenerationModel, OpenAIAudioGenerationResponse, OpenAICompletionsCompletionModel, OpenAIEmbeddingModel, OpenAIImageGenerationModel, OpenAIImageGenerationResponse, OpenAIResponsesCompletionModel, OpenAITranscriptionModel, OpenAITranscriptionResponse, OpenRouterAgent, OpenRouterCompletionsModel, PerplexityAgent, PerplexityCompletionsModel, PolishConfig, R2Range, RequestRedirect, TogetherAgent, TogetherCompletionsModel, TogetherEmbeddingModel, ToolDefinition, ToolFunction, TranscriptionRequest, VoyageAIEmbeddingModel, XaiAgent, XaiCompletionsModel, __wbg_String_8f0eb39a4a4c2f66, __wbg_abort_410ec47a64ac6117, __wbg_abort_775ef1d17fc65868, __wbg_append_299d5d48292c0495, __wbg_append_8c7dd8d641a5f01b, __wbg_append_b2d1fc16de2a0e81, __wbg_append_b44785ebeb668479, __wbg_arrayBuffer_d1b44c4390db422f, __wbg_body_0b8fd1fe671660df, __wbg_buffer_09165b52af8c5237, __wbg_buffer_609cc3eee51ed158, __wbg_byobRequest_77d9adf63337edfb, __wbg_byteLength_e674b853d9c77e1d, __wbg_byteOffset_fd862df290ef848d, __wbg_call_672a4d21634d4a24, __wbg_call_7cccdd69e0791ae2, __wbg_cancel_8a308660caa6cadf, __wbg_catch_a6e601879b2610e9, __wbg_clearTimeout_b1115618e821c3b2, __wbg_close_304cc1fef3466669, __wbg_close_5ce03e29be453811, __wbg_done_769e5ede4b31c67b, __wbg_embedding_new, __wbg_enqueue_bb16ba72f537dc9e, __wbg_entries_3265d4158b33e5dc, __wbg_error_7534b8e9a36f1ab4, __wbg_fetch_3afbdcc7ddbf16fe, __wbg_fetch_509096533071c657, __wbg_from_2a5d3e218e67aa85, __wbg_geminitranscriptionresponse_new, __wbg_getReader_48e00749fe3f6089, __wbg_get_67b2ba62fc30de12, __wbg_get_b9b93047fe3cf45b, __wbg_getdone_d47073731acd3e74, __wbg_getvalue_009dcd63692bee1f, __wbg_getwithrefkey_1dc361bd10053bfe, __wbg_groqtranscriptionresponse_new, __wbg_has_a5ea9117f258a0ec, __wbg_headers_9cb51cfd2ac780a4, __wbg_huggingfaceimagegenerationresponse_new, __wbg_huggingfacetranscriptionresponse_new, __wbg_hyperbolicaudiogenerationresponse_new, __wbg_hyperbolicimagegenerationresponse_new, __wbg_instanceof_ArrayBuffer_e14585432e3737fc, __wbg_instanceof_Map_f3469ce2244d2430, __wbg_instanceof_Promise_935168b8f4b49db3, __wbg_instanceof_Response_f2cc20d9f7dfd644, __wbg_instanceof_Uint8Array_17156bcf118086a9, __wbg_isArray_a1eab7e0d067391b, __wbg_isSafeInteger_343e2beeeece1bb0, __wbg_iterator_9a24c88df860dc65, __wbg_length_a446193dc22c12f8, __wbg_length_e2d2a49132c1b256, __wbg_message_unwrap, __wbg_name_a0a40e66e4d7971f, __wbg_new_018dcc2d6c8c2f6a, __wbg_new_23a2665fac83c611, __wbg_new_405e22f390576ce2, __wbg_new_5e0be73521bc8c17, __wbg_new_78feb108b6472713, __wbg_new_8a6f238a6ece86ea, __wbg_new_9fd39a253424609a, __wbg_new_a12002a7f91c75be, __wbg_new_c68d7209be747379, __wbg_new_e25e5aab09ff45db, __wbg_newnoargs_105ed471475aaf50, __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a, __wbg_newwithintounderlyingsource_b47f6a6a596a7f24, __wbg_newwithstrandinit_06c535e0a867c635, __wbg_newwithu8arraysequenceandoptions_068570c487f69127, __wbg_next_25feadfc0913fea9, __wbg_next_6574e1a8a62d1055, __wbg_openaiaudiogenerationresponse_new, __wbg_openaiimagegenerationresponse_new, __wbg_openaitranscriptionresponse_new, __wbg_push_737cfc8c1432c2c6, __wbg_queueMicrotask_97d92b4fcc8a61c5, __wbg_queueMicrotask_d3219def82552485, __wbg_read_a2434af1186cb56c, __wbg_releaseLock_091899af97991d2e, __wbg_resolve_4851785c9c5f573d, __wbg_respond_1f279fa9f8edcb1c, __wbg_setTimeout_ca12ead8b48245e2, __wbg_set_37837023f3d740e8, __wbg_set_3f1d0b984ed272ed, __wbg_set_65595bdd868b3009, __wbg_set_8fc6bf8a5b1071d1, __wbg_set_wasm, __wbg_setbody_5923b78a95eedf29, __wbg_setcredentials_c3a22f1cd105a2c6, __wbg_setheaders_834c0bdb6a8949ad, __wbg_sethighwatermark_793c99c89830c8e9, __wbg_setmethod_3c5280fe5d890842, __wbg_setmode_5dc300b865044b65, __wbg_setsignal_75b21ef3a81de905, __wbg_settype_39ed370d3edd403c, __wbg_signal_aaf9ad74119f20a4, __wbg_stack_0ed75d68575b0f3c, __wbg_static_accessor_GLOBAL_88a902d13a557d07, __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0, __wbg_static_accessor_SELF_37c5d418e4bf5819, __wbg_static_accessor_WINDOW_5de37043a91a9c40, __wbg_status_f6360336ca686bf0, __wbg_stringify_f7ed6987935b4a24, __wbg_text_7805bea50de2af49, __wbg_then_44b73946d2fb3e7d, __wbg_then_48b406749878a531, __wbg_url_ae10c34ca209681d, __wbg_value_cd1ffa7b1ab794f1, __wbg_view_fd8a56e8983f448d, __wbindgen_array_new, __wbindgen_array_push, __wbindgen_as_number, __wbindgen_bigint_from_i64, __wbindgen_bigint_from_u64, __wbindgen_bigint_get_as_i64, __wbindgen_boolean_get, __wbindgen_cb_drop, __wbindgen_closure_wrapper2099, __wbindgen_closure_wrapper2121, __wbindgen_debug_string, __wbindgen_error_new, __wbindgen_in, __wbindgen_init_externref_table, __wbindgen_is_array, __wbindgen_is_bigint, __wbindgen_is_function, __wbindgen_is_null, __wbindgen_is_object, __wbindgen_is_string, __wbindgen_is_undefined, __wbindgen_jsval_eq, __wbindgen_jsval_loose_eq, __wbindgen_memory, __wbindgen_number_get, __wbindgen_number_new, __wbindgen_string_get, __wbindgen_string_new, __wbindgen_throw, __wbindgen_typeof, initPanicHook };