@xberg-io/liter-llm-wasm 2.1.1 → 2.1.4

package/liter_llm_wasm.js

@@ -158,6 +158,9 @@ export class WasmAssistantMessage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmassistantmessage_free(ptr, 0);
     }
+    clearFunctionCall() {
+        wasm.wasmassistantmessage_clearFunctionCall(this.__wbg_ptr);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -170,6 +173,17 @@ export class WasmAssistantMessage {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmAssistantMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmassistantmessage_copyForTransfer(this.__wbg_ptr);
+        return WasmAssistantMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmAssistantMessage}
      */
@@ -178,6 +192,10 @@ export class WasmAssistantMessage {
         return WasmAssistantMessage.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `functionCall`.
+     *
+     * Changes to the returned value do not update this object. To update `functionCall`,
+     * read it, modify the copy, then assign the copy back to `functionCall`.
      * @returns {WasmFunctionCall | undefined}
      */
     get functionCall() {
@@ -197,6 +215,14 @@ export class WasmAssistantMessage {
         return v1;
     }
     /**
+     * Takes ownership of `functionCall`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `toolCalls`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [content]
      * @param {string | null} [name]
      * @param {WasmToolCall[] | null} [toolCalls]
@@ -307,15 +333,11 @@ export class WasmAssistantMessage {
         wasm.wasmassistantmessage_set_content(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmFunctionCall | null} [value]
+     * @param {WasmFunctionCall} value
      */
     set functionCall(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantmessage_set_functionCall(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmFunctionCall);
+        wasm.wasmassistantmessage_set_functionCall(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -342,6 +364,9 @@ export class WasmAssistantMessage {
         wasm.wasmassistantmessage_set_refusal(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `toolCalls`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmToolCall[] | null} [value]
      */
     set toolCalls(value) {
@@ -366,6 +391,10 @@ export class WasmAssistantMessage {
         return v1;
     }
     /**
+     * Returns detached copies of the elements in `toolCalls`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `toolCalls`.
      * @returns {Array<any> | undefined}
      */
     get toolCalls() {
@@ -405,6 +434,12 @@ export class WasmAssistantPart {
         const ret = wasm.wasmassistantpart_audio(this.__wbg_ptr);
         return ret === 0 ? undefined : WasmAudioContent.__wrap(ret);
     }
+    clearAudio() {
+        wasm.wasmassistantpart_clearAudio(this.__wbg_ptr);
+    }
+    clearImageUrl() {
+        wasm.wasmassistantpart_clearImageUrl(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmAssistantPart}
      */
@@ -438,26 +473,18 @@ export class WasmAssistantPart {
         return v1;
     }
     /**
-     * @param {WasmAudioContent | null} [value]
+     * @param {WasmAudioContent} value
      */
     set audio(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAudioContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantpart_set_audio(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAudioContent);
+        wasm.wasmassistantpart_set_audio(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmassistantpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -536,6 +563,17 @@ export class WasmAudioContent {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmaudiocontent_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmAudioContent}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmaudiocontent_copyForTransfer(this.__wbg_ptr);
+        return WasmAudioContent.__wrap(ret);
+    }
     /**
      * @returns {string}
      */
@@ -641,6 +679,17 @@ export class WasmAuthConfig {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmAuthConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmauthconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmAuthConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmAuthConfig}
      */
@@ -811,6 +860,17 @@ export class WasmBatchListQuery {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmBatchListQuery}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmbatchlistquery_copyForTransfer(this.__wbg_ptr);
+        return WasmBatchListQuery.__wrap(ret);
+    }
     /**
      * @returns {WasmBatchListQuery}
      */
@@ -875,6 +935,21 @@ export class WasmBatchListResponse {
         wasm.__wbg_wasmbatchlistresponse_free(ptr, 0);
     }
     /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmBatchListResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmbatchlistresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmBatchListResponse.__wrap(ret);
+    }
+    /**
+     * Returns detached copies of the elements in `data`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `data`.
      * @returns {WasmBatchObject[]}
      */
     get data() {
@@ -922,6 +997,9 @@ export class WasmBatchListResponse {
         return v1;
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [object]
      * @param {WasmBatchObject[] | null} [data]
      * @param {boolean | null} [hasMore]
@@ -958,6 +1036,9 @@ export class WasmBatchListResponse {
         }
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmBatchObject[]} value
      */
     set data(value) {
@@ -1024,6 +1105,9 @@ export class WasmBatchObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmbatchobject_free(ptr, 0);
     }
+    clearRequestCounts() {
+        wasm.wasmbatchobject_clearRequestCounts(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint | undefined}
      */
@@ -1046,6 +1130,17 @@ export class WasmBatchObject {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmBatchObject}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmbatchobject_copyForTransfer(this.__wbg_ptr);
+        return WasmBatchObject.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -1139,6 +1234,11 @@ export class WasmBatchObject {
         return ret;
     }
     /**
+     * Takes ownership of `requestCounts`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {string | null} [endpoint]
@@ -1207,6 +1307,10 @@ export class WasmBatchObject {
         return v1;
     }
     /**
+     * Returns a detached copy of `requestCounts`.
+     *
+     * Changes to the returned value do not update this object. To update `requestCounts`,
+     * read it, modify the copy, then assign the copy back to `requestCounts`.
      * @returns {WasmBatchRequestCounts | undefined}
      */
     get requestCounts() {
@@ -1300,15 +1404,11 @@ export class WasmBatchObject {
         wasm.wasmbatchobject_set_outputFileId(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmBatchRequestCounts | null} [value]
+     * @param {WasmBatchRequestCounts} value
      */
     set requestCounts(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmBatchRequestCounts);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmbatchobject_set_requestCounts(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmBatchRequestCounts);
+        wasm.wasmbatchobject_set_requestCounts(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmBatchStatus} value
@@ -1361,6 +1461,17 @@ export class WasmBatchRequestCounts {
         const ret = wasm.wasmbatchrequestcounts_completed(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmBatchRequestCounts}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmbatchrequestcounts_copyForTransfer(this.__wbg_ptr);
+        return WasmBatchRequestCounts.__wrap(ret);
+    }
     /**
      * @returns {WasmBatchRequestCounts}
      */
@@ -1474,6 +1585,17 @@ export class WasmBedrockConfig {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmBedrockConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmbedrockconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmBedrockConfig.__wrap(ret);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -1630,6 +1752,17 @@ export class WasmCatalogRefreshConfig {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCatalogRefreshConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcatalogrefreshconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmCatalogRefreshConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmCatalogRefreshConfig}
      */
@@ -1734,6 +1867,10 @@ export class WasmChatCompletionChunk {
         wasm.__wbg_wasmchatcompletionchunk_free(ptr, 0);
     }
     /**
+     * Returns detached copies of the elements in `choices`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `choices`.
      * @returns {WasmStreamChoice[]}
      */
     get choices() {
@@ -1742,6 +1879,20 @@ export class WasmChatCompletionChunk {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    clearUsage() {
+        wasm.wasmchatcompletionchunk_clearUsage(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmChatCompletionChunk}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmchatcompletionchunk_copyForTransfer(this.__wbg_ptr);
+        return WasmChatCompletionChunk.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -1787,6 +1938,14 @@ export class WasmChatCompletionChunk {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `choices`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [created]
@@ -1847,6 +2006,9 @@ export class WasmChatCompletionChunk {
         return v1;
     }
     /**
+     * Takes ownership of every element in `choices`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmStreamChoice[]} value
      */
     set choices(value) {
@@ -1901,15 +2063,11 @@ export class WasmChatCompletionChunk {
         wasm.wasmchatcompletionchunk_set_systemFingerprint(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionchunk_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmchatcompletionchunk_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string | undefined}
@@ -1924,6 +2082,10 @@ export class WasmChatCompletionChunk {
         return v1;
     }
     /**
+     * Returns a detached copy of `usage`.
+     *
+     * Changes to the returned value do not update this object. To update `usage`,
+     * read it, modify the copy, then assign the copy back to `usage`.
      * @returns {WasmUsage | undefined}
      */
     get usage() {
@@ -1960,6 +2122,20 @@ export class WasmChatCompletionRequest {
         const ret = wasm.wasmchatcompletionrequest_audio(this.__wbg_ptr);
         return ret;
     }
+    clearStreamOptions() {
+        wasm.wasmchatcompletionrequest_clearStreamOptions(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmChatCompletionRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmchatcompletionrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmChatCompletionRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmChatCompletionRequest}
      */
@@ -2058,6 +2234,14 @@ export class WasmChatCompletionRequest {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
+     * Takes ownership of `streamOptions`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `tools`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [model]
      * @param {any | null} [messages]
      * @param {number | null} [temperature]
@@ -2302,15 +2486,11 @@ export class WasmChatCompletionRequest {
         wasm.wasmchatcompletionrequest_set_store(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
     }
     /**
-     * @param {WasmStreamOptions | null} [value]
+     * @param {WasmStreamOptions} value
      */
     set streamOptions(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamOptions);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionrequest_set_streamOptions(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamOptions);
+        wasm.wasmchatcompletionrequest_set_streamOptions(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean | null} [value]
@@ -2331,6 +2511,9 @@ export class WasmChatCompletionRequest {
         wasm.wasmchatcompletionrequest_set_toolChoice(this.__wbg_ptr, isLikeNone(value) ? 0 : addToExternrefTable0(value));
     }
     /**
+     * Takes ownership of every element in `tools`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmChatCompletionTool[] | null} [value]
      */
     set tools(value) {
@@ -2379,6 +2562,10 @@ export class WasmChatCompletionRequest {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
+     * Returns a detached copy of `streamOptions`.
+     *
+     * Changes to the returned value do not update this object. To update `streamOptions`,
+     * read it, modify the copy, then assign the copy back to `streamOptions`.
      * @returns {WasmStreamOptions | undefined}
      */
     get streamOptions() {
@@ -2407,6 +2594,10 @@ export class WasmChatCompletionRequest {
         return ret;
     }
     /**
+     * Returns detached copies of the elements in `tools`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `tools`.
      * @returns {Array<any> | undefined}
      */
     get tools() {
@@ -2470,6 +2661,10 @@ export class WasmChatCompletionResponse {
         wasm.__wbg_wasmchatcompletionresponse_free(ptr, 0);
     }
     /**
+     * Returns detached copies of the elements in `choices`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `choices`.
      * @returns {WasmChoice[]}
      */
     get choices() {
@@ -2478,6 +2673,20 @@ export class WasmChatCompletionResponse {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    clearUsage() {
+        wasm.wasmchatcompletionresponse_clearUsage(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmChatCompletionResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmchatcompletionresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmChatCompletionResponse.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -2523,6 +2732,14 @@ export class WasmChatCompletionResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `choices`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [created]
@@ -2583,6 +2800,9 @@ export class WasmChatCompletionResponse {
         return v1;
     }
     /**
+     * Takes ownership of every element in `choices`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmChoice[]} value
      */
     set choices(value) {
@@ -2637,15 +2857,11 @@ export class WasmChatCompletionResponse {
         wasm.wasmchatcompletionresponse_set_systemFingerprint(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmchatcompletionresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string | undefined}
@@ -2660,6 +2876,10 @@ export class WasmChatCompletionResponse {
         return v1;
     }
     /**
+     * Returns a detached copy of `usage`.
+     *
+     * Changes to the returned value do not update this object. To update `usage`,
+     * read it, modify the copy, then assign the copy back to `usage`.
      * @returns {WasmUsage | undefined}
      */
     get usage() {
@@ -2695,6 +2915,17 @@ export class WasmChatCompletionTool {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmchatcompletiontool_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmChatCompletionTool}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmchatcompletiontool_copyForTransfer(this.__wbg_ptr);
+        return WasmChatCompletionTool.__wrap(ret);
+    }
     /**
      * @returns {WasmChatCompletionTool}
      */
@@ -2703,6 +2934,10 @@ export class WasmChatCompletionTool {
         return WasmChatCompletionTool.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `function`.
+     *
+     * Changes to the returned value do not update this object. To update `function`,
+     * read it, modify the copy, then assign the copy back to `function`.
      * @returns {WasmFunctionDefinition}
      */
     get function() {
@@ -2715,8 +2950,7 @@ export class WasmChatCompletionTool {
      */
     constructor(toolType, _function) {
         _assertClass(_function, WasmFunctionDefinition);
-        var ptr0 = _function.__destroy_into_raw();
-        const ret = wasm.wasmchatcompletiontool_new(toolType, ptr0);
+        const ret = wasm.wasmchatcompletiontool_new(toolType, _function.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmChatCompletionToolFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -2726,8 +2960,7 @@ export class WasmChatCompletionTool {
      */
     set function(value) {
         _assertClass(value, WasmFunctionDefinition);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmchatcompletiontool_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmchatcompletiontool_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmToolType} value
@@ -2779,6 +3012,17 @@ export class WasmChoice {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmchoice_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmChoice}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmchoice_copyForTransfer(this.__wbg_ptr);
+        return WasmChoice.__wrap(ret);
+    }
     /**
      * @returns {WasmChoice}
      */
@@ -2813,6 +3057,10 @@ export class WasmChoice {
         return ret;
     }
     /**
+     * Returns a detached copy of `message`.
+     *
+     * Changes to the returned value do not update this object. To update `message`,
+     * read it, modify the copy, then assign the copy back to `message`.
      * @returns {WasmAssistantMessage}
      */
     get message() {
@@ -2820,6 +3068,11 @@ export class WasmChoice {
         return WasmAssistantMessage.__wrap(ret);
     }
     /**
+     * Takes ownership of `message`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {WasmAssistantMessage | null} [message]
      * @param {WasmFinishReason | null} [finishReason]
@@ -2859,8 +3112,7 @@ export class WasmChoice {
      */
     set message(value) {
         _assertClass(value, WasmAssistantMessage);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmchoice_set_message(this.__wbg_ptr, ptr0);
+        wasm.wasmchoice_set_message(this.__wbg_ptr, value.__wbg_ptr);
     }
 }
 if (Symbol.dispose) WasmChoice.prototype[Symbol.dispose] = WasmChoice.prototype.free;
@@ -2885,6 +3137,15 @@ export class WasmContentPart {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcontentpart_free(ptr, 0);
     }
+    clearDocument() {
+        wasm.wasmcontentpart_clearDocument(this.__wbg_ptr);
+    }
+    clearImageUrl() {
+        wasm.wasmcontentpart_clearImageUrl(this.__wbg_ptr);
+    }
+    clearInputAudio() {
+        wasm.wasmcontentpart_clearInputAudio(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmContentPart}
      */
@@ -2920,37 +3181,25 @@ export class WasmContentPart {
         return this;
     }
     /**
-     * @param {WasmDocumentContent | null} [value]
+     * @param {WasmDocumentContent} value
      */
     set document(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmDocumentContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_document(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmDocumentContent);
+        wasm.wasmcontentpart_set_document(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmcontentpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmAudioContent | null} [value]
+     * @param {WasmAudioContent} value
      */
     set inputAudio(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAudioContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_inputAudio(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAudioContent);
+        wasm.wasmcontentpart_set_inputAudio(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -3033,6 +3282,17 @@ export class WasmCreateBatchRequest {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateBatchRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreatebatchrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateBatchRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateBatchRequest}
      */
@@ -3148,6 +3408,17 @@ export class WasmCreateFileRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcreatefilerequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateFileRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreatefilerequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateFileRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateFileRequest}
      */
@@ -3257,6 +3528,17 @@ export class WasmCreateImageRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcreateimagerequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateImageRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreateimagerequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateImageRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateImageRequest}
      */
@@ -3490,6 +3772,17 @@ export class WasmCreateResponseRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcreateresponserequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateResponseRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreateresponserequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateResponseRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateResponseRequest}
      */
@@ -3553,6 +3846,9 @@ export class WasmCreateResponseRequest {
         }
     }
     /**
+     * Takes ownership of every element in `tools`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [model]
      * @param {any | null} [input]
      * @param {string | null} [instructions]
@@ -3628,6 +3924,9 @@ export class WasmCreateResponseRequest {
         wasm.wasmcreateresponserequest_set_temperature(this.__wbg_ptr, !isLikeNone(value), isLikeNone(value) ? 0 : value);
     }
     /**
+     * Takes ownership of every element in `tools`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmResponseTool[] | null} [value]
      */
     set tools(value) {
@@ -3650,6 +3949,10 @@ export class WasmCreateResponseRequest {
         return ret[0] === 0 ? undefined : ret[1];
     }
     /**
+     * Returns detached copies of the elements in `tools`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `tools`.
      * @returns {Array<any> | undefined}
      */
     get tools() {
@@ -3679,6 +3982,17 @@ export class WasmCreateSpeechRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcreatespeechrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateSpeechRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreatespeechrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateSpeechRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateSpeechRequest}
      */
@@ -3832,6 +4146,17 @@ export class WasmCreateTranscriptionRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcreatetranscriptionrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCreateTranscriptionRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcreatetranscriptionrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmCreateTranscriptionRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmCreateTranscriptionRequest}
      */
@@ -4027,6 +4352,17 @@ export class WasmCustomProviderConfig {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmCustomProviderConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmcustomproviderconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmCustomProviderConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmCustomProviderConfig}
      */
@@ -4132,6 +4468,17 @@ export class WasmDecodedDataUrl {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdecodeddataurl_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmDecodedDataUrl}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmdecodeddataurl_copyForTransfer(this.__wbg_ptr);
+        return WasmDecodedDataUrl.__wrap(ret);
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -4199,7 +4546,7 @@ if (Symbol.dispose) WasmDecodedDataUrl.prototype[Symbol.dispose] = WasmDecodedDa
 /**
  * Default client implementation backed by `reqwest`.
  *
- * Sends requests to 165 LLM providers with automatic provider detection
+ * Sends requests to 174 LLM providers with automatic provider detection
  * and per-request routing. The provider is resolved at construction time
  * from `model_hint` (or defaults to OpenAI), but individual requests can
  * override the provider via model name prefix (e.g. `"anthropic/claude-3-5-sonnet"`
@@ -4270,6 +4617,17 @@ export class WasmDefaultClient {
         const ret = wasm.wasmdefaultclient_chat(this.__wbg_ptr, ptr0);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmDefaultClient}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmdefaultclient_copyForTransfer(this.__wbg_ptr);
+        return WasmDefaultClient.__wrap(ret);
+    }
     /**
      * @param {WasmCreateBatchRequest} req
      * @returns {Promise<WasmBatchObject>}
@@ -4521,6 +4879,17 @@ export class WasmDeleteResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdeleteresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmDeleteResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmdeleteresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmDeleteResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmDeleteResponse}
      */
@@ -4640,6 +5009,17 @@ export class WasmDeveloperMessage {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmDeveloperMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmdevelopermessage_copyForTransfer(this.__wbg_ptr);
+        return WasmDeveloperMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmDeveloperMessage}
      */
@@ -4712,6 +5092,17 @@ export class WasmDocumentContent {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdocumentcontent_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmDocumentContent}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmdocumentcontent_copyForTransfer(this.__wbg_ptr);
+        return WasmDocumentContent.__wrap(ret);
+    }
     /**
      * @returns {string}
      */
@@ -4802,6 +5193,9 @@ export class WasmEmbeddingContentPart {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingcontentpart_free(ptr, 0);
     }
+    clearImageUrl() {
+        wasm.wasmembeddingcontentpart_clearImageUrl(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmEmbeddingContentPart}
      */
@@ -4843,15 +5237,11 @@ export class WasmEmbeddingContentPart {
         wasm.wasmembeddingcontentpart_set_imageBase64(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmembeddingcontentpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmembeddingcontentpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -4934,6 +5324,17 @@ export class WasmEmbeddingObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingobject_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmEmbeddingObject}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmembeddingobject_copyForTransfer(this.__wbg_ptr);
+        return WasmEmbeddingObject.__wrap(ret);
+    }
     /**
      * @returns {WasmEmbeddingObject}
      */
@@ -5032,6 +5433,17 @@ export class WasmEmbeddingRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmEmbeddingRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmembeddingrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmEmbeddingRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmEmbeddingRequest}
      */
@@ -5166,7 +5578,25 @@ export class WasmEmbeddingResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingresponse_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmembeddingresponse_clearUsage(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmEmbeddingResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmembeddingresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmEmbeddingResponse.__wrap(ret);
+    }
     /**
+     * Returns detached copies of the elements in `data`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `data`.
      * @returns {WasmEmbeddingObject[]}
      */
     get data() {
@@ -5198,6 +5628,14 @@ export class WasmEmbeddingResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string} object
      * @param {WasmEmbeddingObject[]} data
      * @param {string} model
@@ -5236,6 +5674,9 @@ export class WasmEmbeddingResponse {
         }
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmEmbeddingObject[]} value
      */
     set data(value) {
@@ -5260,17 +5701,17 @@ export class WasmEmbeddingResponse {
         wasm.wasmembeddingresponse_set_object(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmembeddingresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmembeddingresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
+     * Returns a detached copy of `usage`.
+     *
+     * Changes to the returned value do not update this object. To update `usage`,
+     * read it, modify the copy, then assign the copy back to `usage`.
      * @returns {WasmUsage | undefined}
      */
     get usage() {
@@ -5312,6 +5753,17 @@ export class WasmFileListQuery {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFileListQuery}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfilelistquery_copyForTransfer(this.__wbg_ptr);
+        return WasmFileListQuery.__wrap(ret);
+    }
     /**
      * @returns {WasmFileListQuery}
      */
@@ -5399,6 +5851,21 @@ export class WasmFileListResponse {
         wasm.__wbg_wasmfilelistresponse_free(ptr, 0);
     }
     /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFileListResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfilelistresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmFileListResponse.__wrap(ret);
+    }
+    /**
+     * Returns detached copies of the elements in `data`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `data`.
      * @returns {WasmFileObject[]}
      */
     get data() {
@@ -5422,6 +5889,9 @@ export class WasmFileListResponse {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [object]
      * @param {WasmFileObject[] | null} [data]
      * @param {boolean | null} [hasMore]
@@ -5452,6 +5922,9 @@ export class WasmFileListResponse {
         }
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmFileObject[]} value
      */
     set data(value) {
@@ -5509,6 +5982,17 @@ export class WasmFileObject {
         const ret = wasm.wasmfileobject_bytes(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFileObject}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfileobject_copyForTransfer(this.__wbg_ptr);
+        return WasmFileObject.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -5734,6 +6218,17 @@ export class WasmFunctionCall {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFunctionCall}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfunctioncall_copyForTransfer(this.__wbg_ptr);
+        return WasmFunctionCall.__wrap(ret);
+    }
     /**
      * @returns {WasmFunctionCall}
      */
@@ -5809,6 +6304,17 @@ export class WasmFunctionDefinition {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmfunctiondefinition_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFunctionDefinition}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfunctiondefinition_copyForTransfer(this.__wbg_ptr);
+        return WasmFunctionDefinition.__wrap(ret);
+    }
     /**
      * @returns {WasmFunctionDefinition}
      */
@@ -5939,6 +6445,17 @@ export class WasmFunctionMessage {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmFunctionMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmfunctionmessage_copyForTransfer(this.__wbg_ptr);
+        return WasmFunctionMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmFunctionMessage}
      */
@@ -6032,6 +6549,17 @@ export class WasmImage {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmImage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmimage_copyForTransfer(this.__wbg_ptr);
+        return WasmImage.__wrap(ret);
+    }
     /**
      * @returns {WasmImage}
      */
@@ -6143,6 +6671,17 @@ export class WasmImageUrl {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmimageurl_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmImageUrl}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmimageurl_copyForTransfer(this.__wbg_ptr);
+        return WasmImageUrl.__wrap(ret);
+    }
     /**
      * @returns {WasmImageUrl}
      */
@@ -6226,6 +6765,17 @@ export class WasmImagesResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmimagesresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmImagesResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmimagesresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmImagesResponse.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -6234,6 +6784,10 @@ export class WasmImagesResponse {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Returns detached copies of the elements in `data`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `data`.
      * @returns {WasmImage[]}
      */
     get data() {
@@ -6250,6 +6804,9 @@ export class WasmImagesResponse {
         return WasmImagesResponse.__wrap(ret);
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {bigint | null} [created]
      * @param {WasmImage[] | null} [data]
      */
@@ -6268,6 +6825,9 @@ export class WasmImagesResponse {
         wasm.wasmimagesresponse_set_created(this.__wbg_ptr, value);
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmImage[]} value
      */
     set data(value) {
@@ -6298,6 +6858,17 @@ export class WasmJsonSchemaFormat {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmjsonschemaformat_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmJsonSchemaFormat}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmjsonschemaformat_copyForTransfer(this.__wbg_ptr);
+        return WasmJsonSchemaFormat.__wrap(ret);
+    }
     /**
      * @returns {WasmJsonSchemaFormat}
      */
@@ -6394,7 +6965,7 @@ export class WasmJsonSchemaFormat {
 if (Symbol.dispose) WasmJsonSchemaFormat.prototype[Symbol.dispose] = WasmJsonSchemaFormat.prototype.free;
 
 /**
- * Opaque WASM handle for [`liter_llm::error::LiterLlmError`] that exposes introspection methods.
+ * Opaque WASM handle for [`liter_llm::LiterLlmError`] that exposes introspection methods.
  */
 export class WasmLiterLlmError {
     __destroy_into_raw() {
@@ -6431,6 +7002,14 @@ export class WasmLiterLlmError {
         const ret = wasm.wasmliterllmerror_isTransient(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * `retry_after` in whole milliseconds (undefined when absent).
+     * @returns {bigint | undefined}
+     */
+    retryAfter() {
+        const ret = wasm.wasmliterllmerror_retryAfter(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * HTTP status code for this error variant.
      * @returns {number}
@@ -6462,6 +7041,17 @@ export class WasmLlmBudgetConfig {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmllmbudgetconfig_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmBudgetConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllmbudgetconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmBudgetConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmLlmBudgetConfig}
      */
@@ -6570,6 +7160,17 @@ export class WasmLlmCacheConfig {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmCacheConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllmcacheconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmCacheConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmLlmCacheConfig}
      */
@@ -6692,6 +7293,10 @@ export class WasmLlmConfig {
         return v1;
     }
     /**
+     * Returns a detached copy of `bedrock`.
+     *
+     * Changes to the returned value do not update this object. To update `bedrock`,
+     * read it, modify the copy, then assign the copy back to `bedrock`.
      * @returns {WasmBedrockConfig | undefined}
      */
     get bedrock() {
@@ -6699,6 +7304,10 @@ export class WasmLlmConfig {
         return ret === 0 ? undefined : WasmBedrockConfig.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `budget`.
+     *
+     * Changes to the returned value do not update this object. To update `budget`,
+     * read it, modify the copy, then assign the copy back to `budget`.
      * @returns {WasmLlmBudgetConfig | undefined}
      */
     get budget() {
@@ -6706,12 +7315,31 @@ export class WasmLlmConfig {
         return ret === 0 ? undefined : WasmLlmBudgetConfig.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `cache`.
+     *
+     * Changes to the returned value do not update this object. To update `cache`,
+     * read it, modify the copy, then assign the copy back to `cache`.
      * @returns {WasmLlmCacheConfig | undefined}
      */
     get cache() {
         const ret = wasm.wasmllmconfig_cache(this.__wbg_ptr);
         return ret === 0 ? undefined : WasmLlmCacheConfig.__wrap(ret);
     }
+    clearBedrock() {
+        wasm.wasmllmconfig_clearBedrock(this.__wbg_ptr);
+    }
+    clearBudget() {
+        wasm.wasmllmconfig_clearBudget(this.__wbg_ptr);
+    }
+    clearCache() {
+        wasm.wasmllmconfig_clearCache(this.__wbg_ptr);
+    }
+    clearInFlightLimit() {
+        wasm.wasmllmconfig_clearInFlightLimit(this.__wbg_ptr);
+    }
+    clearRateLimit() {
+        wasm.wasmllmconfig_clearRateLimit(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint | undefined}
      */
@@ -6719,6 +7347,17 @@ export class WasmLlmConfig {
         const ret = wasm.wasmllmconfig_cooldownSecs(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllmconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmConfig.__wrap(ret);
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -6748,6 +7387,10 @@ export class WasmLlmConfig {
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
     /**
+     * Returns a detached copy of `inFlightLimit`.
+     *
+     * Changes to the returned value do not update this object. To update `inFlightLimit`,
+     * read it, modify the copy, then assign the copy back to `inFlightLimit`.
      * @returns {WasmLlmInFlightLimitConfig | undefined}
      */
     get inFlightLimit() {
@@ -6791,6 +7434,14 @@ export class WasmLlmConfig {
         }
     }
     /**
+     * Takes ownership of `cache`, `budget`, `rateLimit`, `inFlightLimit`, `bedrock`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `providers`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [model]
      * @param {string | null} [apiKey]
      * @param {string | null} [baseUrl]
@@ -6851,6 +7502,10 @@ export class WasmLlmConfig {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `providers`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `providers`.
      * @returns {Array<any> | undefined}
      */
     get providers() {
@@ -6858,6 +7513,10 @@ export class WasmLlmConfig {
         return ret;
     }
     /**
+     * Returns a detached copy of `rateLimit`.
+     *
+     * Changes to the returned value do not update this object. To update `rateLimit`,
+     * read it, modify the copy, then assign the copy back to `rateLimit`.
      * @returns {WasmLlmRateLimitConfig | undefined}
      */
     get rateLimit() {
@@ -6881,37 +7540,25 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_baseUrl(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmBedrockConfig | null} [value]
+     * @param {WasmBedrockConfig} value
      */
     set bedrock(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmBedrockConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_bedrock(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmBedrockConfig);
+        wasm.wasmllmconfig_set_bedrock(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmLlmBudgetConfig | null} [value]
+     * @param {WasmLlmBudgetConfig} value
      */
     set budget(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmBudgetConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_budget(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmBudgetConfig);
+        wasm.wasmllmconfig_set_budget(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmLlmCacheConfig | null} [value]
+     * @param {WasmLlmCacheConfig} value
      */
     set cache(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmCacheConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_cache(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmCacheConfig);
+        wasm.wasmllmconfig_set_cache(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {bigint | null} [value]
@@ -6938,15 +7585,11 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_healthCheckSecs(this.__wbg_ptr, !isLikeNone(value), isLikeNone(value) ? BigInt(0) : value);
     }
     /**
-     * @param {WasmLlmInFlightLimitConfig | null} [value]
+     * @param {WasmLlmInFlightLimitConfig} value
      */
     set inFlightLimit(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmInFlightLimitConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_inFlightLimit(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmInFlightLimitConfig);
+        wasm.wasmllmconfig_set_inFlightLimit(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean | null} [value]
@@ -6975,6 +7618,9 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_model(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `providers`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmLlmProviderConfig[] | null} [value]
      */
     set providers(value) {
@@ -6983,15 +7629,11 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_providers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmLlmRateLimitConfig | null} [value]
+     * @param {WasmLlmRateLimitConfig} value
      */
     set rateLimit(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmRateLimitConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_rateLimit(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmRateLimitConfig);
+        wasm.wasmllmconfig_set_rateLimit(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {number | null} [value]
@@ -7055,6 +7697,17 @@ export class WasmLlmInFlightLimitConfig {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmllminflightlimitconfig_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmInFlightLimitConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllminflightlimitconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmInFlightLimitConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmLlmInFlightLimitConfig}
      */
@@ -7140,6 +7793,17 @@ export class WasmLlmProviderConfig {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmProviderConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllmproviderconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmProviderConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmLlmProviderConfig}
      */
@@ -7246,6 +7910,17 @@ export class WasmLlmRateLimitConfig {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmllmratelimitconfig_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmLlmRateLimitConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmllmratelimitconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmLlmRateLimitConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmLlmRateLimitConfig}
      */
@@ -7360,6 +8035,17 @@ export class WasmModelInfo {
         const ret = wasm.wasmmodelinfo_cacheReadInputTokenCost(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModelInfo}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmodelinfo_copyForTransfer(this.__wbg_ptr);
+        return WasmModelInfo.__wrap(ret);
+    }
     /**
      * @returns {WasmModelInfo}
      */
@@ -7415,6 +8101,9 @@ export class WasmModelInfo {
         return v1;
     }
     /**
+     * Takes ownership of every element in `tiers`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {number | null} [inputCostPerToken]
      * @param {number | null} [outputCostPerToken]
      * @param {WasmModelTier[] | null} [tiers]
@@ -7577,6 +8266,9 @@ export class WasmModelInfo {
         wasm.wasmmodelinfo_set_supportsVision(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
     }
     /**
+     * Takes ownership of every element in `tiers`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmModelTier[]} value
      */
     set tiers(value) {
@@ -7634,6 +8326,10 @@ export class WasmModelInfo {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
+     * Returns detached copies of the elements in `tiers`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `tiers`.
      * @returns {WasmModelTier[]}
      */
     get tiers() {
@@ -7671,6 +8367,17 @@ export class WasmModelObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmmodelobject_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModelObject}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmodelobject_copyForTransfer(this.__wbg_ptr);
+        return WasmModelObject.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -7822,6 +8529,17 @@ export class WasmModelTier {
         const ret = wasm.wasmmodeltier_cacheReadInputTokenCost(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModelTier}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmodeltier_copyForTransfer(this.__wbg_ptr);
+        return WasmModelTier.__wrap(ret);
+    }
     /**
      * @returns {WasmModelTier}
      */
@@ -7959,6 +8677,21 @@ export class WasmModelsListResponse {
         wasm.__wbg_wasmmodelslistresponse_free(ptr, 0);
     }
     /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModelsListResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmodelslistresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmModelsListResponse.__wrap(ret);
+    }
+    /**
+     * Returns detached copies of the elements in `data`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `data`.
      * @returns {WasmModelObject[]}
      */
     get data() {
@@ -7975,6 +8708,9 @@ export class WasmModelsListResponse {
         return WasmModelsListResponse.__wrap(ret);
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [object]
      * @param {WasmModelObject[] | null} [data]
      */
@@ -8004,6 +8740,9 @@ export class WasmModelsListResponse {
         }
     }
     /**
+     * Takes ownership of every element in `data`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmModelObject[]} value
      */
     set data(value) {
@@ -8042,6 +8781,17 @@ export class WasmModerationCategories {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmmoderationcategories_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModerationCategories}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmoderationcategories_copyForTransfer(this.__wbg_ptr);
+        return WasmModerationCategories.__wrap(ret);
+    }
     /**
      * @returns {WasmModerationCategories}
      */
@@ -8234,6 +8984,17 @@ export class WasmModerationCategoryScores {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmmoderationcategoryscores_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModerationCategoryScores}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmoderationcategoryscores_copyForTransfer(this.__wbg_ptr);
+        return WasmModerationCategoryScores.__wrap(ret);
+    }
     /**
      * @returns {WasmModerationCategoryScores}
      */
@@ -8426,6 +9187,17 @@ export class WasmModerationRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmmoderationrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModerationRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmoderationrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmModerationRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmModerationRequest}
      */
@@ -8501,6 +9273,17 @@ export class WasmModerationResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmmoderationresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModerationResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmoderationresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmModerationResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmModerationResponse}
      */
@@ -8539,6 +9322,9 @@ export class WasmModerationResponse {
         }
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string} id
      * @param {string} model
      * @param {WasmModerationResult[]} results
@@ -8556,6 +9342,10 @@ export class WasmModerationResponse {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `results`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `results`.
      * @returns {WasmModerationResult[]}
      */
     get results() {
@@ -8581,6 +9371,9 @@ export class WasmModerationResponse {
         wasm.wasmmoderationresponse_set_model(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmModerationResult[]} value
      */
     set results(value) {
@@ -8618,6 +9411,10 @@ export class WasmModerationResult {
         wasm.__wbg_wasmmoderationresult_free(ptr, 0);
     }
     /**
+     * Returns a detached copy of `categories`.
+     *
+     * Changes to the returned value do not update this object. To update `categories`,
+     * read it, modify the copy, then assign the copy back to `categories`.
      * @returns {WasmModerationCategories}
      */
     get categories() {
@@ -8625,12 +9422,27 @@ export class WasmModerationResult {
         return WasmModerationCategories.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `categoryScores`.
+     *
+     * Changes to the returned value do not update this object. To update `categoryScores`,
+     * read it, modify the copy, then assign the copy back to `categoryScores`.
      * @returns {WasmModerationCategoryScores}
      */
     get categoryScores() {
         const ret = wasm.wasmmoderationresult_categoryScores(this.__wbg_ptr);
         return WasmModerationCategoryScores.__wrap(ret);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmModerationResult}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmmoderationresult_copyForTransfer(this.__wbg_ptr);
+        return WasmModerationResult.__wrap(ret);
+    }
     /**
      * @returns {WasmModerationResult}
      */
@@ -8652,10 +9464,8 @@ export class WasmModerationResult {
      */
     constructor(flagged, categories, categoryScores) {
         _assertClass(categories, WasmModerationCategories);
-        var ptr0 = categories.__destroy_into_raw();
         _assertClass(categoryScores, WasmModerationCategoryScores);
-        var ptr1 = categoryScores.__destroy_into_raw();
-        const ret = wasm.wasmmoderationresult_new(flagged, ptr0, ptr1);
+        const ret = wasm.wasmmoderationresult_new(flagged, categories.__wbg_ptr, categoryScores.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmModerationResultFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -8665,16 +9475,14 @@ export class WasmModerationResult {
      */
     set categories(value) {
         _assertClass(value, WasmModerationCategories);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmmoderationresult_set_categories(this.__wbg_ptr, ptr0);
+        wasm.wasmmoderationresult_set_categories(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmModerationCategoryScores} value
      */
     set categoryScores(value) {
         _assertClass(value, WasmModerationCategoryScores);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmmoderationresult_set_categoryScores(this.__wbg_ptr, ptr0);
+        wasm.wasmmoderationresult_set_categoryScores(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean} value
@@ -8830,6 +9638,17 @@ export class WasmOcrImage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrimage_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmOcrImage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmocrimage_copyForTransfer(this.__wbg_ptr);
+        return WasmOcrImage.__wrap(ret);
+    }
     /**
      * @returns {WasmOcrImage}
      */
@@ -8923,6 +9742,20 @@ export class WasmOcrPage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrpage_free(ptr, 0);
     }
+    clearDimensions() {
+        wasm.wasmocrpage_clearDimensions(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmOcrPage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmocrpage_copyForTransfer(this.__wbg_ptr);
+        return WasmOcrPage.__wrap(ret);
+    }
     /**
      * @returns {WasmOcrPage}
      */
@@ -8931,6 +9764,10 @@ export class WasmOcrPage {
         return WasmOcrPage.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `dimensions`.
+     *
+     * Changes to the returned value do not update this object. To update `dimensions`,
+     * read it, modify the copy, then assign the copy back to `dimensions`.
      * @returns {WasmPageDimensions | undefined}
      */
     get dimensions() {
@@ -8938,6 +9775,10 @@ export class WasmOcrPage {
         return ret === 0 ? undefined : WasmPageDimensions.__wrap(ret);
     }
     /**
+     * Returns detached copies of the elements in `images`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `images`.
      * @returns {Array<any> | undefined}
      */
     get images() {
@@ -8967,6 +9808,14 @@ export class WasmOcrPage {
         }
     }
     /**
+     * Takes ownership of `dimensions`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `images`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {number} index
      * @param {string} markdown
      * @param {WasmOcrImage[] | null} [images]
@@ -8988,17 +9837,16 @@ export class WasmOcrPage {
         return this;
     }
     /**
-     * @param {WasmPageDimensions | null} [value]
+     * @param {WasmPageDimensions} value
      */
     set dimensions(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmPageDimensions);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmocrpage_set_dimensions(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmPageDimensions);
+        wasm.wasmocrpage_set_dimensions(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
+     * Takes ownership of every element in `images`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmOcrImage[] | null} [value]
      */
     set images(value) {
@@ -9043,6 +9891,17 @@ export class WasmOcrRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmOcrRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmocrrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmOcrRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmOcrRequest}
      */
@@ -9158,6 +10017,20 @@ export class WasmOcrResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrresponse_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmocrresponse_clearUsage(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmOcrResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmocrresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmOcrResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmOcrResponse}
      */
@@ -9181,6 +10054,14 @@ export class WasmOcrResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `pages`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {WasmOcrPage[]} pages
      * @param {string} model
      * @param {WasmUsage | null} [usage]
@@ -9201,6 +10082,10 @@ export class WasmOcrResponse {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `pages`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `pages`.
      * @returns {WasmOcrPage[]}
      */
     get pages() {
@@ -9218,6 +10103,9 @@ export class WasmOcrResponse {
         wasm.wasmocrresponse_set_model(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `pages`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmOcrPage[]} value
      */
     set pages(value) {
@@ -9226,17 +10114,17 @@ export class WasmOcrResponse {
         wasm.wasmocrresponse_set_pages(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmocrresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmocrresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
+     * Returns a detached copy of `usage`.
+     *
+     * Changes to the returned value do not update this object. To update `usage`,
+     * read it, modify the copy, then assign the copy back to `usage`.
      * @returns {WasmUsage | undefined}
      */
     get usage() {
@@ -9266,6 +10154,17 @@ export class WasmPageDimensions {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmpagedimensions_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmPageDimensions}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmpagedimensions_copyForTransfer(this.__wbg_ptr);
+        return WasmPageDimensions.__wrap(ret);
+    }
     /**
      * @returns {WasmPageDimensions}
      */
@@ -9351,6 +10250,17 @@ export class WasmPromptTokensDetails {
         const ret = wasm.wasmprompttokensdetails_cachedTokens(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmPromptTokensDetails}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmprompttokensdetails_copyForTransfer(this.__wbg_ptr);
+        return WasmPromptTokensDetails.__wrap(ret);
+    }
     /**
      * @returns {WasmPromptTokensDetails}
      */
@@ -9427,6 +10337,17 @@ export class WasmProviderCapabilities {
         const ret = wasm.wasmprovidercapabilities_audioOut(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmProviderCapabilities}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmprovidercapabilities_copyForTransfer(this.__wbg_ptr);
+        return WasmProviderCapabilities.__wrap(ret);
+    }
     /**
      * @returns {WasmProviderCapabilities}
      */
@@ -9553,6 +10474,10 @@ export class WasmProviderConfig {
         wasm.__wbg_wasmproviderconfig_free(ptr, 0);
     }
     /**
+     * Returns a detached copy of `auth`.
+     *
+     * Changes to the returned value do not update this object. To update `auth`,
+     * read it, modify the copy, then assign the copy back to `auth`.
      * @returns {WasmAuthConfig | undefined}
      */
     get auth() {
@@ -9571,6 +10496,20 @@ export class WasmProviderConfig {
         }
         return v1;
     }
+    clearAuth() {
+        wasm.wasmproviderconfig_clearAuth(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmProviderConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmproviderconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmProviderConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmProviderConfig}
      */
@@ -9630,6 +10569,11 @@ export class WasmProviderConfig {
         }
     }
     /**
+     * Takes ownership of `auth`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string} name
      * @param {string | null} [displayName]
      * @param {string | null} [baseUrl]
@@ -9667,15 +10611,11 @@ export class WasmProviderConfig {
         return ret;
     }
     /**
-     * @param {WasmAuthConfig | null} [value]
+     * @param {WasmAuthConfig} value
      */
     set auth(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAuthConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmproviderconfig_set_auth(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAuthConfig);
+        wasm.wasmproviderconfig_set_auth(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -9768,6 +10708,17 @@ export class WasmRerankRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmrerankrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmRerankRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmrerankrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmRerankRequest.__wrap(ret);
+    }
     /**
      * @returns {WasmRerankRequest}
      */
@@ -9900,6 +10851,17 @@ export class WasmRerankResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmrerankresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmRerankResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmrerankresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmRerankResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmRerankResponse}
      */
@@ -9927,6 +10889,9 @@ export class WasmRerankResponse {
         return ret;
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {WasmRerankResult[]} results
      * @param {string | null} [id]
      * @param {any | null} [meta]
@@ -9942,6 +10907,10 @@ export class WasmRerankResponse {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `results`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `results`.
      * @returns {WasmRerankResult[]}
      */
     get results() {
@@ -9965,6 +10934,9 @@ export class WasmRerankResponse {
         wasm.wasmrerankresponse_set_meta(this.__wbg_ptr, isLikeNone(value) ? 0 : addToExternrefTable0(value));
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmRerankResult[]} value
      */
     set results(value) {
@@ -10001,6 +10973,20 @@ export class WasmRerankResult {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmrerankresult_free(ptr, 0);
     }
+    clearDocument() {
+        wasm.wasmrerankresult_clearDocument(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmRerankResult}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmrerankresult_copyForTransfer(this.__wbg_ptr);
+        return WasmRerankResult.__wrap(ret);
+    }
     /**
      * @returns {WasmRerankResult}
      */
@@ -10009,6 +10995,10 @@ export class WasmRerankResult {
         return WasmRerankResult.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `document`.
+     *
+     * Changes to the returned value do not update this object. To update `document`,
+     * read it, modify the copy, then assign the copy back to `document`.
      * @returns {WasmRerankResultDocument | undefined}
      */
     get document() {
@@ -10023,6 +11013,11 @@ export class WasmRerankResult {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `document`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number} index
      * @param {number} relevanceScore
      * @param {WasmRerankResultDocument | null} [document]
@@ -10046,15 +11041,11 @@ export class WasmRerankResult {
         return ret;
     }
     /**
-     * @param {WasmRerankResultDocument | null} [value]
+     * @param {WasmRerankResultDocument} value
      */
     set document(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmRerankResultDocument);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmrerankresult_set_document(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmRerankResultDocument);
+        wasm.wasmrerankresult_set_document(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -10091,6 +11082,17 @@ export class WasmRerankResultDocument {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmrerankresultdocument_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmRerankResultDocument}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmrerankresultdocument_copyForTransfer(this.__wbg_ptr);
+        return WasmRerankResultDocument.__wrap(ret);
+    }
     /**
      * @returns {WasmRerankResultDocument}
      */
@@ -10172,6 +11174,9 @@ export class WasmResponseFormat {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresponseformat_free(ptr, 0);
     }
+    clearJsonSchema() {
+        wasm.wasmresponseformat_clearJsonSchema(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmResponseFormat}
      */
@@ -10193,15 +11198,11 @@ export class WasmResponseFormat {
         return this;
     }
     /**
-     * @param {WasmJsonSchemaFormat | null} [value]
+     * @param {WasmJsonSchemaFormat} value
      */
     set jsonSchema(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmJsonSchemaFormat);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmresponseformat_set_jsonSchema(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmJsonSchemaFormat);
+        wasm.wasmresponseformat_set_jsonSchema(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string} value
@@ -10249,6 +11250,20 @@ export class WasmResponseObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresponseobject_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmresponseobject_clearUsage(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmResponseObject}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmresponseobject_copyForTransfer(this.__wbg_ptr);
+        return WasmResponseObject.__wrap(ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -10301,6 +11316,14 @@ export class WasmResponseObject {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `output`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [createdAt]
@@ -10347,6 +11370,10 @@ export class WasmResponseObject {
         }
     }
     /**
+     * Returns detached copies of the elements in `output`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `output`.
      * @returns {WasmResponseOutputItem[]}
      */
     get output() {
@@ -10392,6 +11419,9 @@ export class WasmResponseObject {
         wasm.wasmresponseobject_set_object(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `output`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmResponseOutputItem[]} value
      */
     set output(value) {
@@ -10408,15 +11438,11 @@ export class WasmResponseObject {
         wasm.wasmresponseobject_set_status(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmResponseUsage | null} [value]
+     * @param {WasmResponseUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmResponseUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmresponseobject_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmResponseUsage);
+        wasm.wasmresponseobject_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string}
@@ -10434,6 +11460,10 @@ export class WasmResponseObject {
         }
     }
     /**
+     * Returns a detached copy of `usage`.
+     *
+     * Changes to the returned value do not update this object. To update `usage`,
+     * read it, modify the copy, then assign the copy back to `usage`.
      * @returns {WasmResponseUsage | undefined}
      */
     get usage() {
@@ -10476,6 +11506,17 @@ export class WasmResponseOutputItem {
         const ret = wasm.wasmresponseoutputitem_content(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmResponseOutputItem}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmresponseoutputitem_copyForTransfer(this.__wbg_ptr);
+        return WasmResponseOutputItem.__wrap(ret);
+    }
     /**
      * @returns {WasmResponseOutputItem}
      */
@@ -10560,6 +11601,17 @@ export class WasmResponseTool {
         const ret = wasm.wasmresponsetool_config(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmResponseTool}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmresponsetool_copyForTransfer(this.__wbg_ptr);
+        return WasmResponseTool.__wrap(ret);
+    }
     /**
      * @returns {WasmResponseTool}
      */
@@ -10631,6 +11683,17 @@ export class WasmResponseUsage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresponseusage_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmResponseUsage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmresponseusage_copyForTransfer(this.__wbg_ptr);
+        return WasmResponseUsage.__wrap(ret);
+    }
     /**
      * @returns {WasmResponseUsage}
      */
@@ -10711,6 +11774,17 @@ export class WasmSearchRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmsearchrequest_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSearchRequest}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmsearchrequest_copyForTransfer(this.__wbg_ptr);
+        return WasmSearchRequest.__wrap(ret);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -10861,6 +11935,17 @@ export class WasmSearchResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmsearchresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSearchResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmsearchresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmSearchResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmSearchResponse}
      */
@@ -10884,6 +11969,9 @@ export class WasmSearchResponse {
         }
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {WasmSearchResult[]} results
      * @param {string} model
      */
@@ -10898,6 +11986,10 @@ export class WasmSearchResponse {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `results`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `results`.
      * @returns {WasmSearchResult[]}
      */
     get results() {
@@ -10915,6 +12007,9 @@ export class WasmSearchResponse {
         wasm.wasmsearchresponse_set_model(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `results`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmSearchResult[]} value
      */
     set results(value) {
@@ -10951,6 +12046,17 @@ export class WasmSearchResult {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmsearchresult_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSearchResult}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmsearchresult_copyForTransfer(this.__wbg_ptr);
+        return WasmSearchResult.__wrap(ret);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -11090,6 +12196,17 @@ export class WasmSpecificFunction {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmspecificfunction_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSpecificFunction}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmspecificfunction_copyForTransfer(this.__wbg_ptr);
+        return WasmSpecificFunction.__wrap(ret);
+    }
     /**
      * @returns {WasmSpecificFunction}
      */
@@ -11169,6 +12286,17 @@ export class WasmSpecificToolChoice {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSpecificToolChoice}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmspecifictoolchoice_copyForTransfer(this.__wbg_ptr);
+        return WasmSpecificToolChoice.__wrap(ret);
+    }
     /**
      * @returns {WasmSpecificToolChoice}
      */
@@ -11177,6 +12305,10 @@ export class WasmSpecificToolChoice {
         return WasmSpecificToolChoice.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `function`.
+     *
+     * Changes to the returned value do not update this object. To update `function`,
+     * read it, modify the copy, then assign the copy back to `function`.
      * @returns {WasmSpecificFunction}
      */
     get function() {
@@ -11184,6 +12316,11 @@ export class WasmSpecificToolChoice {
         return WasmSpecificFunction.__wrap(ret);
     }
     /**
+     * Takes ownership of `function`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {WasmToolType | null} [choiceType]
      * @param {WasmSpecificFunction | null} [_function]
      */
@@ -11209,8 +12346,7 @@ export class WasmSpecificToolChoice {
      */
     set function(value) {
         _assertClass(value, WasmSpecificFunction);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmspecifictoolchoice_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmspecifictoolchoice_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
 }
 if (Symbol.dispose) WasmSpecificToolChoice.prototype[Symbol.dispose] = WasmSpecificToolChoice.prototype.free;
@@ -11241,6 +12377,17 @@ export class WasmStreamChoice {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmstreamchoice_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmStreamChoice}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmstreamchoice_copyForTransfer(this.__wbg_ptr);
+        return WasmStreamChoice.__wrap(ret);
+    }
     /**
      * @returns {WasmStreamChoice}
      */
@@ -11249,6 +12396,10 @@ export class WasmStreamChoice {
         return WasmStreamChoice.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `delta`.
+     *
+     * Changes to the returned value do not update this object. To update `delta`,
+     * read it, modify the copy, then assign the copy back to `delta`.
      * @returns {WasmStreamDelta}
      */
     get delta() {
@@ -11275,6 +12426,11 @@ export class WasmStreamChoice {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `delta`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {WasmStreamDelta | null} [delta]
      * @param {WasmFinishReason | null} [finishReason]
@@ -11295,8 +12451,7 @@ export class WasmStreamChoice {
      */
     set delta(value) {
         _assertClass(value, WasmStreamDelta);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmstreamchoice_set_delta(this.__wbg_ptr, ptr0);
+        wasm.wasmstreamchoice_set_delta(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmFinishReason | null} [value]
@@ -11333,6 +12488,9 @@ export class WasmStreamDelta {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmstreamdelta_free(ptr, 0);
     }
+    clearFunctionCall() {
+        wasm.wasmstreamdelta_clearFunctionCall(this.__wbg_ptr);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -11345,6 +12503,17 @@ export class WasmStreamDelta {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmStreamDelta}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmstreamdelta_copyForTransfer(this.__wbg_ptr);
+        return WasmStreamDelta.__wrap(ret);
+    }
     /**
      * @returns {WasmStreamDelta}
      */
@@ -11353,6 +12522,10 @@ export class WasmStreamDelta {
         return WasmStreamDelta.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `functionCall`.
+     *
+     * Changes to the returned value do not update this object. To update `functionCall`,
+     * read it, modify the copy, then assign the copy back to `functionCall`.
      * @returns {WasmStreamFunctionCall | undefined}
      */
     get functionCall() {
@@ -11360,6 +12533,14 @@ export class WasmStreamDelta {
         return ret === 0 ? undefined : WasmStreamFunctionCall.__wrap(ret);
     }
     /**
+     * Takes ownership of `functionCall`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
+     * Takes ownership of every element in `toolCalls`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [role]
      * @param {string | null} [content]
      * @param {WasmStreamToolCall[] | null} [toolCalls]
@@ -11433,15 +12614,11 @@ export class WasmStreamDelta {
         wasm.wasmstreamdelta_set_content(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmStreamFunctionCall | null} [value]
+     * @param {WasmStreamFunctionCall} value
      */
     set functionCall(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmstreamdelta_set_functionCall(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamFunctionCall);
+        wasm.wasmstreamdelta_set_functionCall(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -11468,6 +12645,9 @@ export class WasmStreamDelta {
         wasm.wasmstreamdelta_set_role(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `toolCalls`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmStreamToolCall[] | null} [value]
      */
     set toolCalls(value) {
@@ -11476,6 +12656,10 @@ export class WasmStreamDelta {
         wasm.wasmstreamdelta_set_toolCalls(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Returns detached copies of the elements in `toolCalls`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `toolCalls`.
      * @returns {Array<any> | undefined}
      */
     get toolCalls() {
@@ -11531,6 +12715,17 @@ export class WasmStreamFunctionCall {
         }
         return v1;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmStreamFunctionCall}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmstreamfunctioncall_copyForTransfer(this.__wbg_ptr);
+        return WasmStreamFunctionCall.__wrap(ret);
+    }
     /**
      * @returns {WasmStreamFunctionCall}
      */
@@ -11603,6 +12798,17 @@ export class WasmStreamOptions {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmstreamoptions_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmStreamOptions}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmstreamoptions_copyForTransfer(this.__wbg_ptr);
+        return WasmStreamOptions.__wrap(ret);
+    }
     /**
      * @returns {WasmStreamOptions}
      */
@@ -11673,6 +12879,20 @@ export class WasmStreamToolCall {
         }
         return v1;
     }
+    clearFunction() {
+        wasm.wasmstreamtoolcall_clearFunction(this.__wbg_ptr);
+    }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmStreamToolCall}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmstreamtoolcall_copyForTransfer(this.__wbg_ptr);
+        return WasmStreamToolCall.__wrap(ret);
+    }
     /**
      * @returns {WasmStreamToolCall}
      */
@@ -11681,6 +12901,10 @@ export class WasmStreamToolCall {
         return WasmStreamToolCall.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `function`.
+     *
+     * Changes to the returned value do not update this object. To update `function`,
+     * read it, modify the copy, then assign the copy back to `function`.
      * @returns {WasmStreamFunctionCall | undefined}
      */
     get function() {
@@ -11707,6 +12931,11 @@ export class WasmStreamToolCall {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `function`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {string | null} [id]
      * @param {WasmToolType | null} [callType]
@@ -11732,15 +12961,11 @@ export class WasmStreamToolCall {
         wasm.wasmstreamtoolcall_set_callType(this.__wbg_ptr, isLikeNone(value) ? 1 : value);
     }
     /**
-     * @param {WasmStreamFunctionCall | null} [value]
+     * @param {WasmStreamFunctionCall} value
      */
     set function(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmstreamtoolcall_set_function(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamFunctionCall);
+        wasm.wasmstreamtoolcall_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -11786,6 +13011,17 @@ export class WasmSystemMessage {
         const ret = wasm.wasmsystemmessage_content(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmSystemMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmsystemmessage_copyForTransfer(this.__wbg_ptr);
+        return WasmSystemMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmSystemMessage}
      */
@@ -11875,6 +13111,17 @@ export class WasmToolCall {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmToolCall}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmtoolcall_copyForTransfer(this.__wbg_ptr);
+        return WasmToolCall.__wrap(ret);
+    }
     /**
      * @returns {WasmToolCall}
      */
@@ -11883,6 +13130,10 @@ export class WasmToolCall {
         return WasmToolCall.__wrap(ret);
     }
     /**
+     * Returns a detached copy of `function`.
+     *
+     * Changes to the returned value do not update this object. To update `function`,
+     * read it, modify the copy, then assign the copy back to `function`.
      * @returns {WasmFunctionCall}
      */
     get function() {
@@ -11913,8 +13164,7 @@ export class WasmToolCall {
         const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         _assertClass(_function, WasmFunctionCall);
-        var ptr1 = _function.__destroy_into_raw();
-        const ret = wasm.wasmtoolcall_new(ptr0, len0, callType, ptr1);
+        const ret = wasm.wasmtoolcall_new(ptr0, len0, callType, _function.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmToolCallFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -11930,8 +13180,7 @@ export class WasmToolCall {
      */
     set function(value) {
         _assertClass(value, WasmFunctionCall);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmtoolcall_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmtoolcall_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string} value
@@ -11981,6 +13230,17 @@ export class WasmToolMessage {
         const ret = wasm.wasmtoolmessage_content(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmToolMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmtoolmessage_copyForTransfer(this.__wbg_ptr);
+        return WasmToolMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmToolMessage}
      */
@@ -12087,6 +13347,17 @@ export class WasmTranscriptionResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmtranscriptionresponse_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmTranscriptionResponse}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmtranscriptionresponse_copyForTransfer(this.__wbg_ptr);
+        return WasmTranscriptionResponse.__wrap(ret);
+    }
     /**
      * @returns {WasmTranscriptionResponse}
      */
@@ -12114,6 +13385,9 @@ export class WasmTranscriptionResponse {
         return v1;
     }
     /**
+     * Takes ownership of every element in `segments`.
+     * wasm-bindgen cannot borrow class values nested in an array. To keep those handles,
+     * copy each retained element with `copyForTransfer()` before passing the array.
      * @param {string | null} [text]
      * @param {string | null} [language]
      * @param {number | null} [duration]
@@ -12132,6 +13406,10 @@ export class WasmTranscriptionResponse {
         return this;
     }
     /**
+     * Returns detached copies of the elements in `segments`.
+     *
+     * Changes to the returned values do not update this object. Modify the copies,
+     * then assign the array back to `segments`.
      * @returns {Array<any> | undefined}
      */
     get segments() {
@@ -12153,6 +13431,9 @@ export class WasmTranscriptionResponse {
         wasm.wasmtranscriptionresponse_set_language(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Takes ownership of every element in `segments`.
+     * wasm-bindgen cannot borrow class values nested in an array; copy each retained
+     * element with `copyForTransfer()` before passing the array.
      * @param {WasmTranscriptionSegment[] | null} [value]
      */
     set segments(value) {
@@ -12212,6 +13493,17 @@ export class WasmTranscriptionSegment {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmtranscriptionsegment_free(ptr, 0);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmTranscriptionSegment}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmtranscriptionsegment_copyForTransfer(this.__wbg_ptr);
+        return WasmTranscriptionSegment.__wrap(ret);
+    }
     /**
      * @returns {WasmTranscriptionSegment}
      */
@@ -12318,6 +13610,9 @@ export class WasmUsage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmusage_free(ptr, 0);
     }
+    clearPromptTokensDetails() {
+        wasm.wasmusage_clearPromptTokensDetails(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint}
      */
@@ -12325,6 +13620,17 @@ export class WasmUsage {
         const ret = wasm.wasmusage_completionTokens(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmUsage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmusage_copyForTransfer(this.__wbg_ptr);
+        return WasmUsage.__wrap(ret);
+    }
     /**
      * @returns {WasmUsage}
      */
@@ -12333,6 +13639,11 @@ export class WasmUsage {
         return WasmUsage.__wrap(ret);
     }
     /**
+     * Takes ownership of `promptTokensDetails`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {bigint | null} [promptTokens]
      * @param {bigint | null} [completionTokens]
      * @param {bigint | null} [totalTokens]
@@ -12350,6 +13661,10 @@ export class WasmUsage {
         return this;
     }
     /**
+     * Returns a detached copy of `promptTokensDetails`.
+     *
+     * Changes to the returned value do not update this object. To update `promptTokensDetails`,
+     * read it, modify the copy, then assign the copy back to `promptTokensDetails`.
      * @returns {WasmPromptTokensDetails | undefined}
      */
     get promptTokensDetails() {
@@ -12370,15 +13685,11 @@ export class WasmUsage {
         wasm.wasmusage_set_completionTokens(this.__wbg_ptr, value);
     }
     /**
-     * @param {WasmPromptTokensDetails | null} [value]
+     * @param {WasmPromptTokensDetails} value
      */
     set promptTokensDetails(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmPromptTokensDetails);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmusage_set_promptTokensDetails(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmPromptTokensDetails);
+        wasm.wasmusage_set_promptTokensDetails(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {bigint} value
@@ -12429,6 +13740,17 @@ export class WasmUserMessage {
         const ret = wasm.wasmusermessage_content(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmUserMessage}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmusermessage_copyForTransfer(this.__wbg_ptr);
+        return WasmUserMessage.__wrap(ret);
+    }
     /**
      * @returns {WasmUserMessage}
      */
@@ -12507,6 +13829,17 @@ export class WasmWaitForBatchConfig {
         const ret = wasm.wasmwaitforbatchconfig_backoffMultiplier(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Return an independent handle for an ownership-taking API.
+     *
+     * Use `copyForTransfer()` for each class value placed in an array when the original
+     * handle must remain usable.
+     * @returns {WasmWaitForBatchConfig}
+     */
+    copyForTransfer() {
+        const ret = wasm.wasmwaitforbatchconfig_copyForTransfer(this.__wbg_ptr);
+        return WasmWaitForBatchConfig.__wrap(ret);
+    }
     /**
      * @returns {WasmWaitForBatchConfig}
      */
@@ -12595,7 +13928,7 @@ export function allProviders() {
 /**
  * Return the capability flags for a named provider.
  *
- * Performs an O(n) linear scan over the embedded registry (165 entries).
+ * Performs an O(n) linear scan over the embedded registry (174 entries).
  * Returns an owned value so bindings can pass capability data without
  * borrowing registry internals.
  *
@@ -12768,11 +14101,19 @@ export function createClient(api_key, base_url, timeout_secs, max_retries, model
  * Create a new LLM client from a JSON string.
  *
  * The JSON object accepts the same fields as `liter-llm.toml` (snake_case).
+ * Middleware keys (`cache`, `budget`, `cooldown_secs`, `rate_limit`,
+ * `in_flight_limit`, `health_check_secs`, `cost_tracking`, `tracing`) are
+ * applied: the returned client routes the `LlmClient` methods (`chat`,
+ * `chat_stream`, `embed`, `list_models`, `image_generate`, `speech`,
+ * `transcribe`, `moderate`, `rerank`, `search`, `ocr`) through the managed
+ * Tower stack. File, batch and response operations bypass it. Each `providers`
+ * entry is registered process-wide via `register_custom_provider`.
  *
  * # Errors
  *
- * Returns `LiterLlmError.BadRequest` if `json` is not valid JSON or
- * contains unknown fields.
+ * Returns `LiterLlmError.BadRequest` if `json` is not valid JSON, contains
+ * unknown fields, or sets middleware keys in a build without the `tower` and
+ * `native-http` features. Provider registration failures are propagated.
  * @param {string} json
  * @returns {WasmDefaultClient}
  */
@@ -12961,68 +14302,78 @@ export function unregisterCustomProvider(name) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_bigint_get_as_i64_b482365c149396c8: function(arg0, arg1) {
+        __wbg_String_8564e559799eccda: function(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);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_a2383202b9353e4c: function(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);
         },
-        __wbg___wbindgen_boolean_get_7a12af2b3f899c5a: function(arg0) {
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(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);
         },
-        __wbg___wbindgen_in_50072d4d6e45c193: function(arg0, arg1) {
+        __wbg___wbindgen_in_92f62ee1427d9e49: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_bigint_60fc0336cb14f5d7: function(arg0) {
+        __wbg___wbindgen_is_bigint_b123553bed3bb382: function(arg0) {
             const ret = typeof(arg0) === 'bigint';
             return ret;
         },
-        __wbg___wbindgen_is_function_fcda5e3902d732fe: function(arg0) {
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_edb6b15aa3afe12e: function(arg0) {
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_c4f7cb494a2a21f1: function(arg0) {
+        __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
             const ret = typeof(arg0) === 'string';
             return ret;
         },
-        __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_eq_9fdcd3c0a860dd3b: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_eq_02babf21faa37971: function(arg0, arg1) {
             const ret = arg0 === arg1;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_3c30021c243b64cd: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_677f21e468d6b461: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_1dc732b810cb937c: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(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);
         },
-        __wbg___wbindgen_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
+        __wbg___wbindgen_rethrow_cb2e88c6b2a16733: function(arg0) {
+            throw arg0;
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(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);
@@ -13030,67 +14381,67 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
+        __wbg__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {
             arg0._wbg_cb_unref();
         },
-        __wbg_abort_03f8c5804715cb9a: function(arg0, arg1) {
+        __wbg_abort_334e7f918b7c5047: function(arg0, arg1) {
             arg0.abort(arg1);
         },
-        __wbg_abort_76dea11221098ae5: function(arg0) {
+        __wbg_abort_f78b99d80248bacb: function(arg0) {
             arg0.abort();
         },
-        __wbg_append_66f1ae7ff7ad65c3: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        __wbg_append_1938ed58fb5613b8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
-        __wbg_append_8e87c13f0f08f8cd: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-        }, arguments); },
-        __wbg_append_df9039bc9160a880: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        __wbg_append_627a9b311ac9993b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             arg0.append(getStringFromWasm0(arg1, arg2), arg3);
         }, arguments); },
-        __wbg_append_e6bfd64552783e08: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_append_9b7024062a618f5d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_append_cfa1814e91387699: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             arg0.append(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5));
         }, arguments); },
-        __wbg_arrayBuffer_06f3da76f071d37f: function() { return handleError(function (arg0) {
+        __wbg_arrayBuffer_f07be74819944ea2: function() { return handleError(function (arg0) {
             const ret = arg0.arrayBuffer();
             return ret;
         }, arguments); },
-        __wbg_body_9ee03724e9ad0639: function(arg0) {
+        __wbg_body_4e088733babc630d: function(arg0) {
             const ret = arg0.body;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_buffer_4a989bded7035f57: function(arg0) {
+        __wbg_buffer_56ec2905a66f58b9: function(arg0) {
             const ret = arg0.buffer;
             return ret;
         },
-        __wbg_byobRequest_f161fc37241dd3d4: function(arg0) {
+        __wbg_byobRequest_54f7ce41d584549a: function(arg0) {
             const ret = arg0.byobRequest;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_byteLength_0ddb1795e2c7e689: function(arg0) {
+        __wbg_byteLength_9f985b8373f1f3fe: function(arg0) {
             const ret = arg0.byteLength;
             return ret;
         },
-        __wbg_byteOffset_46eb015f52b6ad7d: function(arg0) {
+        __wbg_byteOffset_0bd5a6a03553639c: function(arg0) {
             const ret = arg0.byteOffset;
             return ret;
         },
-        __wbg_call_269c5566fbede3eb: function() { return handleError(function (arg0, arg1) {
-            const ret = arg0.call(arg1);
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = arg0.call(arg1, arg2);
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_cancel_c076350a7e8954be: function(arg0) {
+        __wbg_cancel_7c2a08c8db4c73f3: function(arg0) {
             const ret = arg0.cancel();
             return ret;
         },
-        __wbg_catch_e2134ef6dcdb69ed: function(arg0, arg1) {
+        __wbg_catch_92594c2d17f55f12: function(arg0, arg1) {
             const ret = arg0.catch(arg1);
             return ret;
         },
@@ -13106,32 +14457,32 @@ function __wbg_get_imports() {
             const ret = clearTimeout(arg0);
             return ret;
         },
-        __wbg_close_22882088c136df25: function() { return handleError(function (arg0) {
+        __wbg_close_185286988f30f252: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
-        __wbg_close_8b609460dd26e367: function() { return handleError(function (arg0) {
+        __wbg_close_748f26698dabe269: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
-        __wbg_done_cffed884d87aa22e: function(arg0) {
+        __wbg_done_b41a1d26cdb37fb6: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_enqueue_6cb545d22db14f33: function() { return handleError(function (arg0, arg1) {
+        __wbg_enqueue_4a01c128f9a0de16: function() { return handleError(function (arg0, arg1) {
             arg0.enqueue(arg1);
         }, arguments); },
-        __wbg_entries_972a87586902cf87: function(arg0) {
-            const ret = Object.entries(arg0);
+        __wbg_entries_b55ec7e0dc443355: function(arg0) {
+            const ret = arg0.entries();
             return ret;
         },
-        __wbg_entries_f9de04c09a57314e: function(arg0) {
-            const ret = arg0.entries();
+        __wbg_entries_fb6397112b1de25f: function(arg0) {
+            const ret = Object.entries(arg0);
             return ret;
         },
         __wbg_fetch_7a37768ab67c5bd8: function(arg0) {
             const ret = fetch(arg0);
             return ret;
         },
-        __wbg_fetch_920242d59bac2026: function(arg0, arg1) {
+        __wbg_fetch_efc64baf325b084d: function(arg0, arg1) {
             const ret = arg0.fetch(arg1);
             return ret;
         },
@@ -13139,35 +14490,35 @@ function __wbg_get_imports() {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_get_6cf5a4d4d8ad3c5a: function() { return handleError(function (arg0, arg1) {
+        __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_b1f0ab13c737f856: function(arg0, arg1) {
+        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_done_a668aa62d81fad70: function(arg0) {
+        __wbg_get_done_7020b91c987365c7: function(arg0) {
             const ret = arg0.done;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg_get_unchecked_363572bdd397d473: function(arg0, arg1) {
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_value_6c62a77c168d825a: function(arg0) {
+        __wbg_get_value_87fbd6ad1283f2e7: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_has_464f8b9416279d65: function() { return handleError(function (arg0, arg1) {
+        __wbg_has_5d6706e5209576c1: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.has(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_headers_2594464ff62969f3: function(arg0) {
+        __wbg_headers_eba93595f8944c2f: function(arg0) {
             const ret = arg0.headers;
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_d4ff01f8247925ae: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -13177,7 +14528,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Map_1ff6a2b54c899f0d: function(arg0) {
+        __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Map;
@@ -13187,7 +14538,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Response_6366a785e400039b: function(arg0) {
+        __wbg_instanceof_Response_b8758567269c30b2: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Response;
@@ -13197,7 +14548,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_598adc0fef426aa8: function(arg0) {
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -13207,70 +14558,70 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_5674713bb7b79043: function(arg0) {
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_8f51c743827d1ec5: function(arg0) {
+        __wbg_isSafeInteger_717808ad6a54bd9e: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_22ddeb808cf55a6f: function() {
+        __wbg_iterator_e3c31c892080e444: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_31bdaf014f5fbde2: function(arg0) {
+        __wbg_length_7f3c00c40364105e: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_4e1adc0d42e23620: function(arg0) {
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_0afe64b4dc16ab74: function() { return handleError(function () {
-            const ret = new Headers();
-            return ret;
-        }, arguments); },
-        __wbg_new_1da3429bc3c4541c: function(arg0) {
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_44f0ed775ff3a5ad: function() { return handleError(function () {
-            const ret = new FormData();
-            return ret;
-        }, arguments); },
-        __wbg_new_8d36e20aa758e411: function() {
+        __wbg_new_28744009d011f847: function() {
             const ret = new Map();
             return ret;
         },
-        __wbg_new_a32a1ab6c6655abe: function(arg0, arg1) {
-            const ret = new Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_new_baa0a0207935dd43: function() { return handleError(function () {
+        __wbg_new_2e41357094e99294: function() { return handleError(function () {
             const ret = new AbortController();
             return ret;
         }, arguments); },
-        __wbg_new_bebc3f4757acf305: function() {
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
             const ret = new Object();
             return ret;
         },
-        __wbg_new_ffa92086ea89f79c: function() {
+        __wbg_new_83ca405eae412a62: function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments); },
+        __wbg_new_d429ac7f5b1a2c5c: function() { return handleError(function () {
+            const ret = new FormData();
+            return ret;
+        }, arguments); },
+        __wbg_new_ee2291f50781bf1d: function() {
             const ret = new Array();
             return ret;
         },
-        __wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_typed_6f8b0d724fe26c07: function(arg0, arg1) {
+        __wbg_new_typed_b01cb72a8af741a3: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
                 var cb0 = (arg0, arg1) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h587dbcc500240430(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -13281,23 +14632,23 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_new_with_byte_offset_and_length_492c969e8b5da8a4: function(arg0, arg1, arg2) {
+        __wbg_new_with_byte_offset_and_length_2f5d7fc2a828b74d: function(arg0, arg1, arg2) {
             const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_str_and_init_2f31a77deda127fd: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_new_with_str_and_init_4618dee4e950224f: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         }, arguments); },
-        __wbg_new_with_u8_array_sequence_and_options_19dab14721682b5e: function() { return handleError(function (arg0, arg1) {
+        __wbg_new_with_u8_array_sequence_and_options_fccc08fe93f4b8fd: function() { return handleError(function (arg0, arg1) {
             const ret = new Blob(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_next_95053e306b1c3aed: function(arg0) {
+        __wbg_next_33784799010f1bbe: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_next_f31ecb8646d2c605: function() { return handleError(function (arg0) {
+        __wbg_next_f4aac29c42af995c: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
@@ -13305,7 +14656,7 @@ function __wbg_get_imports() {
             const ret = arg0.now();
             return ret;
         },
-        __wbg_parse_6937a9050adfb0e1: function() { return handleError(function (arg0, arg1) {
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
@@ -13313,32 +14664,32 @@ function __wbg_get_imports() {
             const ret = arg0.performance;
             return ret;
         },
-        __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_push_bfdf956ba476f65b: function(arg0, arg1) {
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
         },
-        __wbg_queueMicrotask_85c90f6987555d65: function(arg0) {
+        __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
         },
-        __wbg_queueMicrotask_f6a1fa10b81d1fc0: function(arg0) {
+        __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
             queueMicrotask(arg0);
         },
-        __wbg_read_31091533ffadf971: function(arg0) {
+        __wbg_read_2a943774344c9728: function(arg0) {
             const ret = arg0.read();
             return ret;
         },
-        __wbg_releaseLock_1538945f5f183d9f: function(arg0) {
+        __wbg_releaseLock_eb64cd83aa9fcfe4: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_resolve_35ec7e0c6af4c82c: function(arg0) {
+        __wbg_resolve_0076e10020304ede: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
         },
-        __wbg_respond_83a71686e927ca32: function() { return handleError(function (arg0, arg1) {
+        __wbg_respond_c102fabcc79e5ef0: function() { return handleError(function (arg0, arg1) {
             arg0.respond(arg1 >>> 0);
         }, arguments); },
         __wbg_setTimeout_56bcdccbad22fd44: function() { return handleError(function (arg0, arg1) {
@@ -13349,97 +14700,97 @@ function __wbg_get_imports() {
             const ret = setTimeout(arg0, arg1);
             return ret;
         },
-        __wbg_set_13d25b81ab403f5e: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
-        },
-        __wbg_set_5f2ad37e5e02dc7b: function(arg0, arg1, arg2) {
+        __wbg_set_575d3ddb70fe831d: function(arg0, arg1, arg2) {
             arg0.set(getArrayU8FromWasm0(arg1, arg2));
         },
+        __wbg_set_6ae97e73113c4f0b: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_bf6dde4923b9b059: function(arg0, arg1, arg2) {
-            const ret = arg0.set(arg1, arg2);
-            return ret;
+        __wbg_set_bea140a88be9b277: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
         },
-        __wbg_set_body_f39cee72c74a5b02: function(arg0, arg1) {
+        __wbg_set_body_1fb0f1008bfc7df6: function(arg0, arg1) {
             arg0.body = arg1;
         },
-        __wbg_set_cache_6e8c35a5ed76edb1: function(arg0, arg1) {
+        __wbg_set_cache_7507c4cc5938ccc7: function(arg0, arg1) {
             arg0.cache = __wbindgen_enum_RequestCache[arg1];
         },
-        __wbg_set_credentials_bf1d3e014213a571: function(arg0, arg1) {
+        __wbg_set_credentials_e0dcce31ca532b7d: function(arg0, arg1) {
             arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
         },
-        __wbg_set_headers_31d373f68f28bf76: function(arg0, arg1) {
+        __wbg_set_headers_40ad33dcf016613f: function(arg0, arg1) {
             arg0.headers = arg1;
         },
-        __wbg_set_method_82e6c3c083da0734: function(arg0, arg1, arg2) {
+        __wbg_set_method_dcb32343247ec427: function(arg0, arg1, arg2) {
             arg0.method = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_mode_f7e56ed768d0ade0: function(arg0, arg1) {
+        __wbg_set_mode_74e772635acb96ec: function(arg0, arg1) {
             arg0.mode = __wbindgen_enum_RequestMode[arg1];
         },
-        __wbg_set_referrer_13cf56bbccbb2ceb: function(arg0, arg1, arg2) {
+        __wbg_set_referrer_efd0fb956d6b70b2: function(arg0, arg1, arg2) {
             arg0.referrer = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_referrer_policy_dac1caa6e937479a: function(arg0, arg1) {
+        __wbg_set_referrer_policy_465382f52c1a03d3: function(arg0, arg1) {
             arg0.referrerPolicy = __wbindgen_enum_ReferrerPolicy[arg1];
         },
-        __wbg_set_signal_f4b32f40f19786f4: function(arg0, arg1) {
+        __wbg_set_signal_2dbd377604627f26: function(arg0, arg1) {
             arg0.signal = arg1;
         },
-        __wbg_set_type_69954a3c7c11a724: function(arg0, arg1, arg2) {
+        __wbg_set_type_dcf75b2afa60c694: function(arg0, arg1, arg2) {
             arg0.type = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_signal_45367c6c2255877a: function(arg0) {
+        __wbg_signal_e5a49a2d9c65b7f6: function(arg0) {
             const ret = arg0.signal;
             return ret;
         },
-        __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_SELF_d8b50611246a6d92: function() {
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_WINDOW_fd0bc376bf0f8b42: function() {
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_status_88ccc72fe7bea621: function(arg0) {
+        __wbg_status_ce0a98d3c57125f3: function(arg0) {
             const ret = arg0.status;
             return ret;
         },
-        __wbg_text_b00323a194b10fa8: function() { return handleError(function (arg0) {
+        __wbg_text_ff3f476b3d6b1246: function() { return handleError(function (arg0) {
             const ret = arg0.text();
             return ret;
         }, arguments); },
-        __wbg_then_7a850dae4493f353: function(arg0, arg1, arg2) {
+        __wbg_then_c949d5a25a4e78f8: function(arg0, arg1, arg2) {
             const ret = arg0.then(arg1, arg2);
             return ret;
         },
-        __wbg_then_b830475380919203: function(arg0, arg1) {
+        __wbg_then_e71170d78fcf8954: function(arg0, arg1) {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_url_f1948b0d7f881e02: function(arg0, arg1) {
+        __wbg_url_8e28edeab4cd6bed: function(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);
         },
-        __wbg_value_c227f843d21da141: function(arg0) {
+        __wbg_value_f3c585ee8f5ba40c: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_view_d8c7b26e4d4650f1: function(arg0) {
+        __wbg_view_9c570f33e8d6ab96: function(arg0) {
             const ret = arg0.view;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
@@ -13672,23 +15023,23 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 923, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 958, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 938, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 976, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 838, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 873, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 871, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 906, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4366f5359ad471a6);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0) {
@@ -13734,27 +15085,27 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h4366f5359ad471a6(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h4366f5359ad471a6(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h587dbcc500240430(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h587dbcc500240430(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(arg0, arg1, arg2, arg3);
 }