@agntcy/slim-bindings-linux-arm64-gnu 2.0.0-alpha.3 → 2.0.0-alpha.4

package/slim_rpc.js

@@ -0,0 +1,3660 @@
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule from "./slim_rpc-ffi.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterDuration, FfiConverterInt32, FfiConverterMap, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterTimestamp, FfiConverterUInt64, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCallAsyncWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
+import uniffiSlimBindingsModule from "./slim_bindings.js";
+const { FfiConverterTypeApp, FfiConverterTypeName } = uniffiSlimBindingsModule.converters;
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+const uniffiIsDebug = 
+// @ts-ignore -- The process global might not be defined
+typeof process !== "object" ||
+    // @ts-ignore -- The process global might not be defined
+    process?.env?.NODE_ENV !== "production" ||
+    false;
+/**
+ * Generated factory for {@link RpcMessageContext} record objects.
+ */
+export const RpcMessageContext = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeRpcMessageContext = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                source: FfiConverterTypeName.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeName.write(value.source, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeName.allocationSize(value.source);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link RpcMulticastItem} record objects.
+ */
+export const RpcMulticastItem = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeRpcMulticastItem = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                context: FfiConverterTypeRpcMessageContext.read(from),
+                message: FfiConverterArrayBuffer.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeRpcMessageContext.write(value.context, into);
+            FfiConverterArrayBuffer.write(value.message, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeRpcMessageContext.allocationSize(value.context) +
+                FfiConverterArrayBuffer.allocationSize(value.message);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * gRPC status codes
+ */
+export var RpcCode;
+(function (RpcCode) {
+    /**
+     * Success
+     */
+    RpcCode[RpcCode["Ok"] = 0] = "Ok";
+    /**
+     * The operation was cancelled
+     */
+    RpcCode[RpcCode["Cancelled"] = 1] = "Cancelled";
+    /**
+     * Unknown error
+     */
+    RpcCode[RpcCode["Unknown"] = 2] = "Unknown";
+    /**
+     * Client specified an invalid argument
+     */
+    RpcCode[RpcCode["InvalidArgument"] = 3] = "InvalidArgument";
+    /**
+     * Deadline exceeded before operation could complete
+     */
+    RpcCode[RpcCode["DeadlineExceeded"] = 4] = "DeadlineExceeded";
+    /**
+     * Some requested entity was not found
+     */
+    RpcCode[RpcCode["NotFound"] = 5] = "NotFound";
+    /**
+     * Some entity that we attempted to create already exists
+     */
+    RpcCode[RpcCode["AlreadyExists"] = 6] = "AlreadyExists";
+    /**
+     * The caller does not have permission to execute the specified operation
+     */
+    RpcCode[RpcCode["PermissionDenied"] = 7] = "PermissionDenied";
+    /**
+     * Some resource has been exhausted
+     */
+    RpcCode[RpcCode["ResourceExhausted"] = 8] = "ResourceExhausted";
+    /**
+     * The system is not in a state required for the operation's execution
+     */
+    RpcCode[RpcCode["FailedPrecondition"] = 9] = "FailedPrecondition";
+    /**
+     * The operation was aborted
+     */
+    RpcCode[RpcCode["Aborted"] = 10] = "Aborted";
+    /**
+     * Operation was attempted past the valid range
+     */
+    RpcCode[RpcCode["OutOfRange"] = 11] = "OutOfRange";
+    /**
+     * Operation is not implemented or not supported
+     */
+    RpcCode[RpcCode["Unimplemented"] = 12] = "Unimplemented";
+    /**
+     * Internal errors
+     */
+    RpcCode[RpcCode["Internal"] = 13] = "Internal";
+    /**
+     * The service is currently unavailable
+     */
+    RpcCode[RpcCode["Unavailable"] = 14] = "Unavailable";
+    /**
+     * Unrecoverable data loss or corruption
+     */
+    RpcCode[RpcCode["DataLoss"] = 15] = "DataLoss";
+    /**
+     * The request does not have valid authentication credentials
+     */
+    RpcCode[RpcCode["Unauthenticated"] = 16] = "Unauthenticated";
+})(RpcCode || (RpcCode = {}));
+const FfiConverterTypeRpcCode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return RpcCode.Ok;
+                case 2: return RpcCode.Cancelled;
+                case 3: return RpcCode.Unknown;
+                case 4: return RpcCode.InvalidArgument;
+                case 5: return RpcCode.DeadlineExceeded;
+                case 6: return RpcCode.NotFound;
+                case 7: return RpcCode.AlreadyExists;
+                case 8: return RpcCode.PermissionDenied;
+                case 9: return RpcCode.ResourceExhausted;
+                case 10: return RpcCode.FailedPrecondition;
+                case 11: return RpcCode.Aborted;
+                case 12: return RpcCode.OutOfRange;
+                case 13: return RpcCode.Unimplemented;
+                case 14: return RpcCode.Internal;
+                case 15: return RpcCode.Unavailable;
+                case 16: return RpcCode.DataLoss;
+                case 17: return RpcCode.Unauthenticated;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case RpcCode.Ok: return ordinalConverter.write(1, into);
+                case RpcCode.Cancelled: return ordinalConverter.write(2, into);
+                case RpcCode.Unknown: return ordinalConverter.write(3, into);
+                case RpcCode.InvalidArgument: return ordinalConverter.write(4, into);
+                case RpcCode.DeadlineExceeded: return ordinalConverter.write(5, into);
+                case RpcCode.NotFound: return ordinalConverter.write(6, into);
+                case RpcCode.AlreadyExists: return ordinalConverter.write(7, into);
+                case RpcCode.PermissionDenied: return ordinalConverter.write(8, into);
+                case RpcCode.ResourceExhausted: return ordinalConverter.write(9, into);
+                case RpcCode.FailedPrecondition: return ordinalConverter.write(10, into);
+                case RpcCode.Aborted: return ordinalConverter.write(11, into);
+                case RpcCode.OutOfRange: return ordinalConverter.write(12, into);
+                case RpcCode.Unimplemented: return ordinalConverter.write(13, into);
+                case RpcCode.Internal: return ordinalConverter.write(14, into);
+                case RpcCode.Unavailable: return ordinalConverter.write(15, into);
+                case RpcCode.DataLoss: return ordinalConverter.write(16, into);
+                case RpcCode.Unauthenticated: return ordinalConverter.write(17, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s) => encoder.encode(s),
+        bytesToString: (ab) => decoder.decode(ab),
+        stringByteLength: (s) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s, buf, offset) => {
+            const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+// Error type: RpcError
+export var RpcError_Tags;
+(function (RpcError_Tags) {
+    RpcError_Tags["Rpc"] = "Rpc";
+    RpcError_Tags["MulticastRpc"] = "MulticastRpc";
+    RpcError_Tags["MulticastSessionClosed"] = "MulticastSessionClosed";
+})(RpcError_Tags || (RpcError_Tags = {}));
+/**
+ * UniFFI-compatible RPC error
+ *
+ * This represents RPC errors with gRPC-compatible status codes.
+ */
+export const RpcError = (() => {
+    var _q, _r, _s;
+    class Rpc_ extends UniffiError {
+        constructor(inner) {
+            super("RpcError", "Rpc");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_q] = "RpcError";
+            this.tag = RpcError_Tags.Rpc;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Rpc_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === RpcError_Tags.Rpc;
+        }
+        static hasInner(obj) {
+            return Rpc_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    _q = uniffiTypeNameSymbol;
+    class MulticastRpc_ extends UniffiError {
+        constructor(inner) {
+            super("RpcError", "MulticastRpc");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_r] = "RpcError";
+            this.tag = RpcError_Tags.MulticastRpc;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new MulticastRpc_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === RpcError_Tags.MulticastRpc;
+        }
+        static hasInner(obj) {
+            return MulticastRpc_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    _r = uniffiTypeNameSymbol;
+    class MulticastSessionClosed_ extends UniffiError {
+        constructor(inner) {
+            super("RpcError", "MulticastSessionClosed");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_s] = "RpcError";
+            this.tag = RpcError_Tags.MulticastSessionClosed;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new MulticastSessionClosed_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === RpcError_Tags.MulticastSessionClosed;
+        }
+        static hasInner(obj) {
+            return MulticastSessionClosed_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    _s = uniffiTypeNameSymbol;
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "RpcError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Rpc: Rpc_,
+        MulticastRpc: MulticastRpc_,
+        MulticastSessionClosed: MulticastSessionClosed_
+    });
+})();
+// FfiConverter for enum RpcError
+const FfiConverterTypeRpcError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new RpcError.Rpc({ code: FfiConverterTypeRpcCode.read(from), message: FfiConverterString.read(from), details: FfiConverterOptionalBytes.read(from) });
+                case 2: return new RpcError.MulticastRpc({ origin: FfiConverterString.read(from), code: FfiConverterTypeRpcCode.read(from), message: FfiConverterString.read(from), details: FfiConverterOptionalBytes.read(from) });
+                case 3: return new RpcError.MulticastSessionClosed({ completed: FfiConverterUInt64.read(from), total: FfiConverterUInt64.read(from), received: FfiConverterSequenceString.read(from), missing: FfiConverterSequenceString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case RpcError_Tags.Rpc: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRpcCode.write(inner.code, into);
+                    FfiConverterString.write(inner.message, into);
+                    FfiConverterOptionalBytes.write(inner.details, into);
+                    return;
+                }
+                case RpcError_Tags.MulticastRpc: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.origin, into);
+                    FfiConverterTypeRpcCode.write(inner.code, into);
+                    FfiConverterString.write(inner.message, into);
+                    FfiConverterOptionalBytes.write(inner.details, into);
+                    return;
+                }
+                case RpcError_Tags.MulticastSessionClosed: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterUInt64.write(inner.completed, into);
+                    FfiConverterUInt64.write(inner.total, into);
+                    FfiConverterSequenceString.write(inner.received, into);
+                    FfiConverterSequenceString.write(inner.missing, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that RpcError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case RpcError_Tags.Rpc: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterTypeRpcCode.allocationSize(inner.code);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    size += FfiConverterOptionalBytes.allocationSize(inner.details);
+                    return size;
+                }
+                case RpcError_Tags.MulticastRpc: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.origin);
+                    size += FfiConverterTypeRpcCode.allocationSize(inner.code);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    size += FfiConverterOptionalBytes.allocationSize(inner.details);
+                    return size;
+                }
+                case RpcError_Tags.MulticastSessionClosed: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterUInt64.allocationSize(inner.completed);
+                    size += FfiConverterUInt64.allocationSize(inner.total);
+                    size += FfiConverterSequenceString.allocationSize(inner.received);
+                    size += FfiConverterSequenceString.allocationSize(inner.missing);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Enum: MulticastStreamMessage
+export var MulticastStreamMessage_Tags;
+(function (MulticastStreamMessage_Tags) {
+    MulticastStreamMessage_Tags["Data"] = "Data";
+    MulticastStreamMessage_Tags["Error"] = "Error";
+    MulticastStreamMessage_Tags["End"] = "End";
+})(MulticastStreamMessage_Tags || (MulticastStreamMessage_Tags = {}));
+/**
+ * Message from a multicast response stream.
+ */
+export const MulticastStreamMessage = (() => {
+    var _q, _r, _s;
+    /**
+     * Successfully received response item with source context.
+     */
+    class Data_ extends UniffiEnum {
+        constructor(inner) {
+            super("MulticastStreamMessage", "Data");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_q] = "MulticastStreamMessage";
+            this.tag = MulticastStreamMessage_Tags.Data;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Data_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === MulticastStreamMessage_Tags.Data;
+        }
+    }
+    _q = uniffiTypeNameSymbol;
+    /**
+     * Error from one member — other members may still be active.
+     */
+    class Error_ extends UniffiEnum {
+        constructor(inner) {
+            super("MulticastStreamMessage", "Error");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_r] = "MulticastStreamMessage";
+            this.tag = MulticastStreamMessage_Tags.Error;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Error_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === MulticastStreamMessage_Tags.Error;
+        }
+    }
+    _r = uniffiTypeNameSymbol;
+    /**
+     * All members have finished — the stream has ended.
+     */
+    class End_ extends UniffiEnum {
+        constructor() {
+            super("MulticastStreamMessage", "End");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_s] = "MulticastStreamMessage";
+            this.tag = MulticastStreamMessage_Tags.End;
+        }
+        static new() {
+            return new End_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === MulticastStreamMessage_Tags.End;
+        }
+    }
+    _s = uniffiTypeNameSymbol;
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "MulticastStreamMessage";
+    }
+    return Object.freeze({
+        instanceOf,
+        Data: Data_,
+        Error: Error_,
+        End: End_
+    });
+})();
+// FfiConverter for enum MulticastStreamMessage
+const FfiConverterTypeMulticastStreamMessage = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new MulticastStreamMessage.Data({ item: FfiConverterTypeRpcMulticastItem.read(from) });
+                case 2: return new MulticastStreamMessage.Error({ error: FfiConverterTypeRpcError.read(from) });
+                case 3: return new MulticastStreamMessage.End();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case MulticastStreamMessage_Tags.Data: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRpcMulticastItem.write(inner.item, into);
+                    return;
+                }
+                case MulticastStreamMessage_Tags.Error: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRpcError.write(inner.error, into);
+                    return;
+                }
+                case MulticastStreamMessage_Tags.End: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that MulticastStreamMessage_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case MulticastStreamMessage_Tags.Data: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterTypeRpcMulticastItem.allocationSize(inner.item);
+                    return size;
+                }
+                case MulticastStreamMessage_Tags.Error: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterTypeRpcError.allocationSize(inner.error);
+                    return size;
+                }
+                case MulticastStreamMessage_Tags.End: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Enum: StreamMessage
+export var StreamMessage_Tags;
+(function (StreamMessage_Tags) {
+    StreamMessage_Tags["Data"] = "Data";
+    StreamMessage_Tags["Error"] = "Error";
+    StreamMessage_Tags["End"] = "End";
+})(StreamMessage_Tags || (StreamMessage_Tags = {}));
+/**
+ * Message from a stream
+ */
+export const StreamMessage = (() => {
+    var _q, _r, _s;
+    /**
+     * Successfully received data
+     */
+    class Data_ extends UniffiEnum {
+        constructor(v0) {
+            super("StreamMessage", "Data");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_q] = "StreamMessage";
+            this.tag = StreamMessage_Tags.Data;
+            this.inner = Object.freeze([v0]);
+        }
+        static new(v0) {
+            return new Data_(v0);
+        }
+        static instanceOf(obj) {
+            return obj.tag === StreamMessage_Tags.Data;
+        }
+    }
+    _q = uniffiTypeNameSymbol;
+    /**
+     * Stream error occurred
+     */
+    class Error_ extends UniffiEnum {
+        constructor(v0) {
+            super("StreamMessage", "Error");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_r] = "StreamMessage";
+            this.tag = StreamMessage_Tags.Error;
+            this.inner = Object.freeze([v0]);
+        }
+        static new(v0) {
+            return new Error_(v0);
+        }
+        static instanceOf(obj) {
+            return obj.tag === StreamMessage_Tags.Error;
+        }
+    }
+    _r = uniffiTypeNameSymbol;
+    /**
+     * Stream has ended
+     */
+    class End_ extends UniffiEnum {
+        constructor() {
+            super("StreamMessage", "End");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_s] = "StreamMessage";
+            this.tag = StreamMessage_Tags.End;
+        }
+        static new() {
+            return new End_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === StreamMessage_Tags.End;
+        }
+    }
+    _s = uniffiTypeNameSymbol;
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "StreamMessage";
+    }
+    return Object.freeze({
+        instanceOf,
+        Data: Data_,
+        Error: Error_,
+        End: End_
+    });
+})();
+// FfiConverter for enum StreamMessage
+const FfiConverterTypeStreamMessage = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new StreamMessage.Data(FfiConverterArrayBuffer.read(from));
+                case 2: return new StreamMessage.Error(FfiConverterTypeRpcError.read(from));
+                case 3: return new StreamMessage.End();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case StreamMessage_Tags.Data: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterArrayBuffer.write(inner[0], into);
+                    return;
+                }
+                case StreamMessage_Tags.Error: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterTypeRpcError.write(inner[0], into);
+                    return;
+                }
+                case StreamMessage_Tags.End: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that StreamMessage_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case StreamMessage_Tags.Data: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterArrayBuffer.allocationSize(inner[0]);
+                    return size;
+                }
+                case StreamMessage_Tags.Error: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterTypeRpcError.allocationSize(inner[0]);
+                    return size;
+                }
+                case StreamMessage_Tags.End: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Bidirectional stream handler for stream-to-stream RPC calls
+ *
+ * Allows sending and receiving messages concurrently.
+ */
+export class BidiStreamHandler extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_a] = "BidiStreamHandler";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeBidiStreamHandlerObjectFactory.bless(pointer);
+    }
+    /**
+     * Close the request stream (no more messages will be sent)
+     */
+    closeSend() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_close_send(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Close the request stream (async version)
+     */
+    async closeSendAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_close_send_async(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Receive the next response message (blocking version)
+     */
+    recv() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeStreamMessage.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_recv(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Receive the next response message (async version)
+     */
+    async recvAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_recv_async(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeStreamMessage.lift.bind(FfiConverterTypeStreamMessage), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Send a request message to the stream (blocking version)
+     */
+    send(data) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_send(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Send a request message to the stream (async version)
+     */
+    async sendAsync(data, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_bidistreamhandler_send_async(uniffiTypeBidiStreamHandlerObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeBidiStreamHandlerObjectFactory.pointer(this);
+            uniffiTypeBidiStreamHandlerObjectFactory.freePointer(pointer);
+            uniffiTypeBidiStreamHandlerObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeBidiStreamHandlerObjectFactory.isConcreteType(obj_);
+    }
+}
+_a = uniffiTypeNameSymbol;
+const uniffiTypeBidiStreamHandlerObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeBidiStreamHandlerObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(BidiStreamHandler.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "BidiStreamHandler";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_bidistreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_bidistreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "BidiStreamHandler";
+        },
+    };
+})();
+const FfiConverterTypeBidiStreamHandler = new FfiConverterObject(uniffiTypeBidiStreamHandlerObjectFactory);
+/**
+ * Bidirectional stream handler for multicast stream-to-unary and
+ * stream-to-stream RPC calls.
+ *
+ * Send request messages via [`send`](Self::send) / [`send_async`](Self::send_async),
+ * close the request stream via [`close_send`](Self::close_send), and receive
+ * responses via [`recv`](Self::recv) / [`recv_async`](Self::recv_async). Each
+ * response item carries the source member's identity.
+ */
+export class MulticastBidiStreamHandler extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_b] = "MulticastBidiStreamHandler";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeMulticastBidiStreamHandlerObjectFactory.bless(pointer);
+    }
+    /**
+     * Close the request stream — signals that no more messages will be sent
+     * (blocking).
+     */
+    closeSend() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_close_send(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Close the request stream (async).
+     */
+    async closeSendAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_close_send_async(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Receive the next response item (blocking).
+     */
+    recv() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeMulticastStreamMessage.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_recv(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Receive the next response item (async).
+     */
+    async recvAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_recv_async(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeMulticastStreamMessage.lift.bind(FfiConverterTypeMulticastStreamMessage), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Send a request message to the stream (blocking).
+     */
+    send(data) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_send(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Send a request message to the stream (async).
+     */
+    async sendAsync(data, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_multicastbidistreamhandler_send_async(uniffiTypeMulticastBidiStreamHandlerObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeMulticastBidiStreamHandlerObjectFactory.pointer(this);
+            uniffiTypeMulticastBidiStreamHandlerObjectFactory.freePointer(pointer);
+            uniffiTypeMulticastBidiStreamHandlerObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeMulticastBidiStreamHandlerObjectFactory.isConcreteType(obj_);
+    }
+}
+_b = uniffiTypeNameSymbol;
+const uniffiTypeMulticastBidiStreamHandlerObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeMulticastBidiStreamHandlerObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(MulticastBidiStreamHandler.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "MulticastBidiStreamHandler";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_multicastbidistreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_multicastbidistreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "MulticastBidiStreamHandler";
+        },
+    };
+})();
+const FfiConverterTypeMulticastBidiStreamHandler = new FfiConverterObject(uniffiTypeMulticastBidiStreamHandlerObjectFactory);
+/**
+ * Response stream reader for multicast RPC calls.
+ *
+ * Allows pulling `RpcMulticastItem`s from a GROUP response stream one at a
+ * time. Each item carries the source member's identity alongside the payload.
+ */
+export class MulticastResponseReader extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_c] = "MulticastResponseReader";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeMulticastResponseReaderObjectFactory.bless(pointer);
+    }
+    /**
+     * Pull the next item from the multicast response stream (blocking).
+     */
+    next() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeMulticastStreamMessage.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_multicastresponsereader_next(uniffiTypeMulticastResponseReaderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Pull the next item from the multicast response stream (async).
+     */
+    async nextAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_multicastresponsereader_next_async(uniffiTypeMulticastResponseReaderObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeMulticastStreamMessage.lift.bind(FfiConverterTypeMulticastStreamMessage), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeMulticastResponseReaderObjectFactory.pointer(this);
+            uniffiTypeMulticastResponseReaderObjectFactory.freePointer(pointer);
+            uniffiTypeMulticastResponseReaderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeMulticastResponseReaderObjectFactory.isConcreteType(obj_);
+    }
+}
+_c = uniffiTypeNameSymbol;
+const uniffiTypeMulticastResponseReaderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeMulticastResponseReaderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(MulticastResponseReader.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "MulticastResponseReader";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_multicastresponsereader(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_multicastresponsereader(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "MulticastResponseReader";
+        },
+    };
+})();
+const FfiConverterTypeMulticastResponseReader = new FfiConverterObject(uniffiTypeMulticastResponseReaderObjectFactory);
+/**
+ * Request stream writer for stream-to-unary RPC calls
+ *
+ * Allows sending multiple request messages and getting a final response.
+ */
+export class RequestStreamWriter extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_d] = "RequestStreamWriter";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeRequestStreamWriterObjectFactory.bless(pointer);
+    }
+    /**
+     * Finalize the stream and get the response (async version)
+     *
+     * **Deprecated**: Use [`finalize_stream_async`](Self::finalize_stream_async) instead.
+     */
+    async finalizeAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_requeststreamwriter_finalize_async(uniffiTypeRequestStreamWriterObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Finalize the stream and get the response (blocking version)
+     */
+    finalizeStream() {
+        return ((__rb) => {
+            try {
+                return FfiConverterArrayBuffer.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_requeststreamwriter_finalize_stream(uniffiTypeRequestStreamWriterObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Finalize the stream and get the response (async version)
+     */
+    async finalizeStreamAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_requeststreamwriter_finalize_stream_async(uniffiTypeRequestStreamWriterObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Send a request message to the stream (blocking version)
+     */
+    send(data) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_requeststreamwriter_send(uniffiTypeRequestStreamWriterObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Send a request message to the stream (async version)
+     */
+    async sendAsync(data, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_requeststreamwriter_send_async(uniffiTypeRequestStreamWriterObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRequestStreamWriterObjectFactory.pointer(this);
+            uniffiTypeRequestStreamWriterObjectFactory.freePointer(pointer);
+            uniffiTypeRequestStreamWriterObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeRequestStreamWriterObjectFactory.isConcreteType(obj_);
+    }
+}
+_d = uniffiTypeNameSymbol;
+const uniffiTypeRequestStreamWriterObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeRequestStreamWriterObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(RequestStreamWriter.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "RequestStreamWriter";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_requeststreamwriter(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_requeststreamwriter(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "RequestStreamWriter";
+        },
+    };
+})();
+const FfiConverterTypeRequestStreamWriter = new FfiConverterObject(uniffiTypeRequestStreamWriterObjectFactory);
+/**
+ * Response stream reader for unary-to-stream RPC calls
+ *
+ * Allows pulling messages from a server response stream one at a time.
+ */
+export class ResponseStreamReader extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_e] = "ResponseStreamReader";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeResponseStreamReaderObjectFactory.bless(pointer);
+    }
+    /**
+     * Pull the next message from the response stream (blocking version)
+     *
+     * Returns a StreamMessage indicating the result
+     */
+    next() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeStreamMessage.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_responsestreamreader_next(uniffiTypeResponseStreamReaderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Pull the next message from the response stream (async version)
+     *
+     * Returns a StreamMessage indicating the result
+     */
+    async nextAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_responsestreamreader_next_async(uniffiTypeResponseStreamReaderObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeStreamMessage.lift.bind(FfiConverterTypeStreamMessage), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeResponseStreamReaderObjectFactory.pointer(this);
+            uniffiTypeResponseStreamReaderObjectFactory.freePointer(pointer);
+            uniffiTypeResponseStreamReaderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeResponseStreamReaderObjectFactory.isConcreteType(obj_);
+    }
+}
+_e = uniffiTypeNameSymbol;
+const uniffiTypeResponseStreamReaderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeResponseStreamReaderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(ResponseStreamReader.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "ResponseStreamReader";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_responsestreamreader(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_responsestreamreader(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ResponseStreamReader";
+        },
+    };
+})();
+const FfiConverterTypeResponseStreamReader = new FfiConverterObject(uniffiTypeResponseStreamReaderObjectFactory);
+/**
+ * Client-side channel for making RPC calls.
+ *
+ * Manages a single persistent SLIM session: either a `PointToPoint` session
+ * to a single remote server, or a `Multicast` (GROUP) session shared across
+ * multiple remote servers. The session is lazily initialised and recreated
+ * when dead.
+ *
+ * ## Constructor
+ *
+ * - `new_with_members_internal(app, members)` — Smart constructor:
+ * - **1 member**: creates a P2P channel.
+ * - **Many members**: creates a GROUP channel with a generated session name
+ * and auto-invites all members on the first multicast call.
+ */
+export class Channel extends UniffiAbstractObject {
+    constructor(app, remote) {
+        super();
+        this[_f] = "Channel";
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_channel_new(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterTypeName.lower(remote, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeChannelObjectFactory.bless(pointer);
+    }
+    static newGroup(app, members) {
+        return FfiConverterTypeChannel.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_channel_new_group(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterSequenceTypeName.lower(members, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    static newGroupWithConnection(app, members, connectionId) {
+        return FfiConverterTypeChannel.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_channel_new_group_with_connection(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterSequenceTypeName.lower(members, nativeModule().rustbuffer_alloc), FfiConverterOptionalUInt64.lower(connectionId, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    static newWithConnection(app, remote, connectionId) {
+        return FfiConverterTypeChannel.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_channel_new_with_connection(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterTypeName.lower(remote, nativeModule().rustbuffer_alloc), FfiConverterOptionalUInt64.lower(connectionId, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Broadcast a request stream to all GROUP members and stream their
+     * responses.
+     *
+     * Semantically equivalent to `call_multicast_stream_unary` at the
+     * transport level; the difference (one vs many responses per member) is
+     * determined by the server handler.
+     */
+    callMulticastStreamStream(serviceName, methodName, timeout, metadata) {
+        return FfiConverterTypeMulticastBidiStreamHandler.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_stream_stream(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Broadcast a request stream to all GROUP members and collect their
+     * responses.
+     *
+     * Returns a handler that lets you send requests and receive responses
+     * concurrently. Use `send` / `send_async` to push request messages,
+     * `close_send` / `close_send_async` to signal end-of-requests, and
+     * `recv` / `recv_async` to pull response items.
+     */
+    callMulticastStreamUnary(serviceName, methodName, timeout, metadata) {
+        return FfiConverterTypeMulticastBidiStreamHandler.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_stream_unary(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Broadcast one request to all GROUP members and collect their responses.
+     *
+     * Returns a reader from which each member's response (wrapped in
+     * `MulticastStreamMessage`) can be pulled one at a time (blocking).
+     */
+    callMulticastUnary(serviceName, methodName, request, timeout, metadata) {
+        return FfiConverterTypeMulticastResponseReader.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_unary(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Broadcast one request to all GROUP members and collect their responses
+     * (async).
+     */
+    async callMulticastUnaryAsync(serviceName, methodName, request, timeout, metadata, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_unary_async(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeMulticastResponseReader.lift.bind(FfiConverterTypeMulticastResponseReader), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Broadcast one request to all GROUP members and stream their responses
+     * (blocking).
+     *
+     * Semantically identical to `call_multicast_unary` at the transport level;
+     * the difference is that each member may send multiple responses before its
+     * EOS, which the server handler determines.
+     */
+    callMulticastUnaryStream(serviceName, methodName, request, timeout, metadata) {
+        return FfiConverterTypeMulticastResponseReader.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_unary_stream(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Broadcast one request to all GROUP members and stream their responses
+     * (async).
+     */
+    async callMulticastUnaryStreamAsync(serviceName, methodName, request, timeout, metadata, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_channel_call_multicast_unary_stream_async(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeMulticastResponseReader.lift.bind(FfiConverterTypeMulticastResponseReader), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    callStreamStream(serviceName, methodName, timeout, metadata) {
+        return FfiConverterTypeBidiStreamHandler.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_stream_stream(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    callStreamUnary(serviceName, methodName, timeout, metadata) {
+        return FfiConverterTypeRequestStreamWriter.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_stream_unary(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    callUnary(serviceName, methodName, request, timeout, metadata) {
+        return ((__rb) => {
+            try {
+                return FfiConverterArrayBuffer.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_unary(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    async callUnaryAsync(serviceName, methodName, request, timeout, metadata, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_channel_call_unary_async(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    callUnaryStream(serviceName, methodName, request, timeout, metadata) {
+        return FfiConverterTypeResponseStreamReader.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_channel_call_unary_stream(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    async callUnaryStreamAsync(serviceName, methodName, request, timeout, metadata, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_channel_call_unary_stream_async(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), FfiConverterOptionalMapStringString.lower(metadata, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeResponseStreamReader.lift.bind(FfiConverterTypeResponseStreamReader), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Async FFI wrapper for [`Channel::close`].
+     */
+    async closeAsync(timeout, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_channel_close_async(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Blocking FFI wrapper for [`Channel::close`].
+     */
+    closeBlocking(timeout) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_channel_close_blocking(uniffiTypeChannelObjectFactory.clonePointer(this), FfiConverterOptionalDuration.lower(timeout, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeChannelObjectFactory.pointer(this);
+            uniffiTypeChannelObjectFactory.freePointer(pointer);
+            uniffiTypeChannelObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeChannelObjectFactory.isConcreteType(obj_);
+    }
+}
+_f = uniffiTypeNameSymbol;
+const uniffiTypeChannelObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeChannelObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Channel.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Channel";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_channel(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_channel(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Channel";
+        },
+    };
+})();
+const FfiConverterTypeChannel = new FfiConverterObject(uniffiTypeChannelObjectFactory);
+/**
+ * Context passed to RPC handlers
+ *
+ * Contains all contextual information about an RPC call including:
+ * - Session information (source, destination, session ID)
+ * - Metadata (key-value pairs)
+ * - Deadline/timeout information
+ * - Message routing details
+ */
+export class Context extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_g] = "Context";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeContextObjectFactory.bless(pointer);
+    }
+    /**
+     * Get the deadline for this RPC call
+     */
+    deadline() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTimestamp.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_context_deadline(uniffiTypeContextObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Check if the deadline has been exceeded
+     */
+    isDeadlineExceeded() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_context_is_deadline_exceeded(uniffiTypeContextObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Get the rpc session metadata
+     */
+    metadata() {
+        return ((__rb) => {
+            try {
+                return FfiConverterMapStringString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_context_metadata(uniffiTypeContextObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Get the remaining time until deadline
+     *
+     * Returns Duration::ZERO if the deadline has already passed
+     */
+    remainingTime() {
+        return ((__rb) => {
+            try {
+                return FfiConverterDuration.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_context_remaining_time(uniffiTypeContextObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Get the session ID
+     */
+    sessionId() {
+        return ((__rb) => {
+            try {
+                return FfiConverterString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_context_session_id(uniffiTypeContextObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeContextObjectFactory.pointer(this);
+            uniffiTypeContextObjectFactory.freePointer(pointer);
+            uniffiTypeContextObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeContextObjectFactory.isConcreteType(obj_);
+    }
+}
+_g = uniffiTypeNameSymbol;
+const uniffiTypeContextObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeContextObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Context.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Context";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_context(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_context(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Context";
+        },
+    };
+})();
+const FfiConverterTypeContext = new FfiConverterObject(uniffiTypeContextObjectFactory);
+/**
+ * Request stream reader
+ *
+ * Allows pulling messages from a client request stream.
+ * This wraps the underlying async stream and provides a blocking interface
+ * suitable for UniFFI callback traits.
+ */
+export class RequestStream extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_h] = "RequestStream";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeRequestStreamObjectFactory.bless(pointer);
+    }
+    /**
+     * Pull the next message from the stream (blocking version)
+     *
+     * Returns a StreamMessage indicating the result
+     */
+    next() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeStreamMessage.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_requeststream_next(uniffiTypeRequestStreamObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Pull the next message from the stream (async version)
+     *
+     * Returns a StreamMessage indicating the result
+     */
+    async nextAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_requeststream_next_async(uniffiTypeRequestStreamObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeStreamMessage.lift.bind(FfiConverterTypeStreamMessage), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeRequestStreamObjectFactory.pointer(this);
+            uniffiTypeRequestStreamObjectFactory.freePointer(pointer);
+            uniffiTypeRequestStreamObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeRequestStreamObjectFactory.isConcreteType(obj_);
+    }
+}
+_h = uniffiTypeNameSymbol;
+const uniffiTypeRequestStreamObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeRequestStreamObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(RequestStream.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "RequestStream";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_requeststream(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_requeststream(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "RequestStream";
+        },
+    };
+})();
+const FfiConverterTypeRequestStream = new FfiConverterObject(uniffiTypeRequestStreamObjectFactory);
+/**
+ * Response stream writer
+ *
+ * Allows pushing messages to a client response stream.
+ * This wraps an async channel sender and provides a blocking interface
+ * suitable for UniFFI callback traits.
+ */
+export class ResponseSink extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_j] = "ResponseSink";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeResponseSinkObjectFactory.bless(pointer);
+    }
+    /**
+     * Close the response stream (blocking version)
+     *
+     * Signals that no more messages will be sent.
+     * The stream will end gracefully.
+     */
+    close() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_responsesink_close(uniffiTypeResponseSinkObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Close the response stream (async version)
+     *
+     * Signals that no more messages will be sent.
+     * The stream will end gracefully.
+     */
+    async closeAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_responsesink_close_async(uniffiTypeResponseSinkObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Check if the sink has been closed (blocking version)
+     */
+    isClosed() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_method_responsesink_is_closed(uniffiTypeResponseSinkObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Check if the sink has been closed (async version)
+     */
+    async isClosedAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_responsesink_is_closed_async(uniffiTypeResponseSinkObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_i8, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_i8, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_i8, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_i8, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterBool.lift.bind(FfiConverterBool), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Send a message to the response stream (blocking version)
+     *
+     * Returns an error if the stream has been closed or if sending fails.
+     */
+    send(data) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_responsesink_send(uniffiTypeResponseSinkObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Send a message to the response stream (async version)
+     *
+     * Returns an error if the stream has been closed or if sending fails.
+     */
+    async sendAsync(data, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_responsesink_send_async(uniffiTypeResponseSinkObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Send an error to the response stream and close it (blocking version)
+     *
+     * This terminates the stream with an error status.
+     */
+    sendError(error) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_responsesink_send_error(uniffiTypeResponseSinkObjectFactory.clonePointer(this), FfiConverterTypeRpcError.lower(error, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Send an error to the response stream and close it (async version)
+     *
+     * This terminates the stream with an error status.
+     */
+    async sendErrorAsync(error, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_responsesink_send_error_async(uniffiTypeResponseSinkObjectFactory.clonePointer(this), FfiConverterTypeRpcError.lower(error, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeResponseSinkObjectFactory.pointer(this);
+            uniffiTypeResponseSinkObjectFactory.freePointer(pointer);
+            uniffiTypeResponseSinkObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeResponseSinkObjectFactory.isConcreteType(obj_);
+    }
+}
+_j = uniffiTypeNameSymbol;
+const uniffiTypeResponseSinkObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeResponseSinkObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(ResponseSink.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "ResponseSink";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_responsesink(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_responsesink(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ResponseSink";
+        },
+    };
+})();
+const FfiConverterTypeResponseSink = new FfiConverterObject(uniffiTypeResponseSinkObjectFactory);
+/**
+ * Stream-to-Stream RPC handler trait
+ *
+ * Implement this trait to handle stream-to-stream RPC calls.
+ * The handler receives multiple requests via the stream and sends multiple responses via the sink.
+ */
+export class StreamStreamHandlerImpl extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_k] = "StreamStreamHandlerImpl";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeStreamStreamHandlerImplObjectFactory.bless(pointer);
+    }
+    /**
+     * Handle a stream-to-stream RPC call
+     *
+     * # Arguments
+     * * `stream` - Request stream to pull messages from
+     * * `context` - RPC context with metadata and session information
+     * * `sink` - Response sink to send streaming responses
+     *
+     * # Returns
+     * Ok(()) if handling succeeded, or an error
+     *
+     * # Note
+     * You must call `sink.close()` or `sink.send_error()` when done.
+     */
+    async handle(stream, context, sink, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_streamstreamhandler_handle(uniffiTypeStreamStreamHandlerImplObjectFactory.clonePointer(this), FfiConverterTypeRequestStream.lower(stream, nativeModule().rustbuffer_alloc), FfiConverterTypeContext.lower(context, nativeModule().rustbuffer_alloc), FfiConverterTypeResponseSink.lower(sink, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeStreamStreamHandlerImplObjectFactory.pointer(this);
+            uniffiTypeStreamStreamHandlerImplObjectFactory.freePointer(pointer);
+            uniffiTypeStreamStreamHandlerImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeStreamStreamHandlerImplObjectFactory.isConcreteType(obj_);
+    }
+}
+_k = uniffiTypeNameSymbol;
+const uniffiTypeStreamStreamHandlerImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeStreamStreamHandlerImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(StreamStreamHandlerImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "StreamStreamHandlerImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_streamstreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_streamstreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StreamStreamHandlerImpl";
+        },
+    };
+})();
+const FfiConverterTypeStreamStreamHandler = new FfiConverterObjectWithCallbacks(uniffiTypeStreamStreamHandlerImplObjectFactory);
+// Add a vtable for the callbacks that go in StreamStreamHandler.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceStreamStreamHandler = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        handle: (uniffiHandle, stream, context, sink, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeStreamStreamHandler.lift(uniffiHandle);
+                return await jsCallback.handle(FfiConverterTypeRequestStream.lift(stream), FfiConverterTypeContext.lift(context), FfiConverterTypeResponseSink.lift(sink), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ RpcError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeRpcError.lower.bind(FfiConverterTypeRpcError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeStreamStreamHandler.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeStreamStreamHandler.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_slim_rpc_fn_init_callback_vtable_streamstreamhandler(uniffiCallbackInterfaceStreamStreamHandler.vtable);
+    },
+};
+/**
+ * Stream-to-Unary RPC handler trait
+ *
+ * Implement this trait to handle stream-to-unary RPC calls.
+ * The handler receives multiple requests via the stream and returns a single response.
+ */
+export class StreamUnaryHandlerImpl extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_l] = "StreamUnaryHandlerImpl";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeStreamUnaryHandlerImplObjectFactory.bless(pointer);
+    }
+    /**
+     * Handle a stream-to-unary RPC call
+     *
+     * # Arguments
+     * * `stream` - Request stream to pull messages from
+     * * `context` - RPC context with metadata and session information
+     *
+     * # Returns
+     * The response message bytes or an error
+     */
+    async handle(stream, context, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_streamunaryhandler_handle(uniffiTypeStreamUnaryHandlerImplObjectFactory.clonePointer(this), FfiConverterTypeRequestStream.lower(stream, nativeModule().rustbuffer_alloc), FfiConverterTypeContext.lower(context, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeStreamUnaryHandlerImplObjectFactory.pointer(this);
+            uniffiTypeStreamUnaryHandlerImplObjectFactory.freePointer(pointer);
+            uniffiTypeStreamUnaryHandlerImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeStreamUnaryHandlerImplObjectFactory.isConcreteType(obj_);
+    }
+}
+_l = uniffiTypeNameSymbol;
+const uniffiTypeStreamUnaryHandlerImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeStreamUnaryHandlerImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(StreamUnaryHandlerImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "StreamUnaryHandlerImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_streamunaryhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_streamunaryhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StreamUnaryHandlerImpl";
+        },
+    };
+})();
+const FfiConverterTypeStreamUnaryHandler = new FfiConverterObjectWithCallbacks(uniffiTypeStreamUnaryHandlerImplObjectFactory);
+// Add a vtable for the callbacks that go in StreamUnaryHandler.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceStreamUnaryHandler = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        handle: (uniffiHandle, stream, context, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeStreamUnaryHandler.lift(uniffiHandle);
+                return await jsCallback.handle(FfiConverterTypeRequestStream.lift(stream), FfiConverterTypeContext.lift(context), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterArrayBuffer.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ RpcError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeRpcError.lower.bind(FfiConverterTypeRpcError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeStreamUnaryHandler.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeStreamUnaryHandler.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_slim_rpc_fn_init_callback_vtable_streamunaryhandler(uniffiCallbackInterfaceStreamUnaryHandler.vtable);
+    },
+};
+/**
+ * Unary-to-Stream RPC handler trait
+ *
+ * Implement this trait to handle unary-to-stream RPC calls.
+ * The handler receives a single request and sends multiple responses via the sink.
+ */
+export class UnaryStreamHandlerImpl extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_m] = "UnaryStreamHandlerImpl";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeUnaryStreamHandlerImplObjectFactory.bless(pointer);
+    }
+    /**
+     * Handle a unary-to-stream RPC call
+     *
+     * # Arguments
+     * * `request` - The request message bytes
+     * * `context` - RPC context with metadata and session information
+     * * `sink` - Response sink to send streaming responses
+     *
+     * # Returns
+     * Ok(()) if handling succeeded, or an error
+     *
+     * # Note
+     * You must call `sink.close()` or `sink.send_error()` when done.
+     */
+    async handle(request, context, sink, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_unarystreamhandler_handle(uniffiTypeUnaryStreamHandlerImplObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterTypeContext.lower(context, nativeModule().rustbuffer_alloc), FfiConverterTypeResponseSink.lower(sink, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeUnaryStreamHandlerImplObjectFactory.pointer(this);
+            uniffiTypeUnaryStreamHandlerImplObjectFactory.freePointer(pointer);
+            uniffiTypeUnaryStreamHandlerImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeUnaryStreamHandlerImplObjectFactory.isConcreteType(obj_);
+    }
+}
+_m = uniffiTypeNameSymbol;
+const uniffiTypeUnaryStreamHandlerImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeUnaryStreamHandlerImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(UnaryStreamHandlerImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "UnaryStreamHandlerImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_unarystreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_unarystreamhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "UnaryStreamHandlerImpl";
+        },
+    };
+})();
+const FfiConverterTypeUnaryStreamHandler = new FfiConverterObjectWithCallbacks(uniffiTypeUnaryStreamHandlerImplObjectFactory);
+// Add a vtable for the callbacks that go in UnaryStreamHandler.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceUnaryStreamHandler = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        handle: (uniffiHandle, request, context, sink, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeUnaryStreamHandler.lift(uniffiHandle);
+                return await jsCallback.handle(FfiConverterArrayBuffer.lift(request), FfiConverterTypeContext.lift(context), FfiConverterTypeResponseSink.lift(sink), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ RpcError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeRpcError.lower.bind(FfiConverterTypeRpcError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeUnaryStreamHandler.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeUnaryStreamHandler.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_slim_rpc_fn_init_callback_vtable_unarystreamhandler(uniffiCallbackInterfaceUnaryStreamHandler.vtable);
+    },
+};
+/**
+ * Unary-to-Unary RPC handler trait
+ *
+ * Implement this trait to handle unary-to-unary RPC calls.
+ * The handler receives a single request and returns a single response.
+ */
+export class UnaryUnaryHandlerImpl extends UniffiAbstractObject {
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[_o] = "UnaryUnaryHandlerImpl";
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeUnaryUnaryHandlerImplObjectFactory.bless(pointer);
+    }
+    /**
+     * Handle a unary-to-unary RPC call
+     *
+     * # Arguments
+     * * `request` - The request message bytes
+     * * `context` - RPC context with metadata and session information
+     *
+     * # Returns
+     * The response message bytes or an error
+     */
+    async handle(request, context, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_unaryunaryhandler_handle(uniffiTypeUnaryUnaryHandlerImplObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(request, nativeModule().rustbuffer_alloc), FfiConverterTypeContext.lower(context, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(FfiConverterArrayBuffer), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeUnaryUnaryHandlerImplObjectFactory.pointer(this);
+            uniffiTypeUnaryUnaryHandlerImplObjectFactory.freePointer(pointer);
+            uniffiTypeUnaryUnaryHandlerImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeUnaryUnaryHandlerImplObjectFactory.isConcreteType(obj_);
+    }
+}
+_o = uniffiTypeNameSymbol;
+const uniffiTypeUnaryUnaryHandlerImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeUnaryUnaryHandlerImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(UnaryUnaryHandlerImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "UnaryUnaryHandlerImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_unaryunaryhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_unaryunaryhandler(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "UnaryUnaryHandlerImpl";
+        },
+    };
+})();
+const FfiConverterTypeUnaryUnaryHandler = new FfiConverterObjectWithCallbacks(uniffiTypeUnaryUnaryHandlerImplObjectFactory);
+// Add a vtable for the callbacks that go in UnaryUnaryHandler.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceUnaryUnaryHandler = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        handle: (uniffiHandle, request, context, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeUnaryUnaryHandler.lift(uniffiHandle);
+                return await jsCallback.handle(FfiConverterArrayBuffer.lift(request), FfiConverterTypeContext.lift(context), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterArrayBuffer.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ RpcError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeRpcError.lower.bind(FfiConverterTypeRpcError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeUnaryUnaryHandler.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeUnaryUnaryHandler.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_slim_rpc_fn_init_callback_vtable_unaryunaryhandler(uniffiCallbackInterfaceUnaryUnaryHandler.vtable);
+    },
+};
+/**
+ * RPC Server
+ *
+ * Handles incoming RPC requests by creating sessions and dispatching
+ * to registered service handlers.
+ *
+ * # Example
+ *
+ * ```ignore
+ * # use slim_bindings::{Server, Context, RpcError, Decoder, Encoder, App, Name};
+ * # use std::sync::Arc;
+ * # fn main() -> Result<(), Box<dyn std::error::Error>> {
+ * # use slim_bindings::{IdentityProviderConfig, IdentityVerifierConfig};
+ * # let app_name = Arc::new(Name::new("test".to_string(), "app".to_string(), "v1".to_string()));
+ * # let provider = IdentityProviderConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
+ * # let verifier = IdentityVerifierConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
+ * # let app = App::new(app_name, provider, verifier)?;
+ * # let core_app = app.inner();
+ * # let notification_rx = app.notification_receiver();
+ * # #[derive(Default)]
+ * # struct Request {}
+ * # impl Decoder for Request {
+ * #     fn decode(_buf: impl Into<Vec<u8>>) -> Result<Self, RpcError> { Ok(Request::default()) }
+ * # }
+ * # #[derive(Default)]
+ * # struct Response {}
+ * # impl Encoder for Response {
+ * #     fn encode(self) -> Result<Vec<u8>, RpcError> { Ok(vec![]) }
+ * # }
+ * let base_name = Name::new("org".to_string(), "namespace".to_string(), "service".to_string());
+ * let server = Server::new_with_shared_rx_and_connection(core_app, base_name.as_slim_name(), None, notification_rx, None);
+ *
+ * // Register handlers
+ * server.register_unary_unary_internal(
+ * "MyService",
+ * "MyMethod",
+ * |request: Request, _ctx: Context| async move {
+ * Ok(Response::default())
+ * }
+ * );
+ * # Ok(())
+ * # }
+ * ```
+ */
+export class Server extends UniffiAbstractObject {
+    /**
+     * Create a new RPC server
+     *
+     * This is the primary constructor for creating an RPC server instance
+     * that can handle incoming RPC requests over SLIM.
+     *
+     * # Arguments
+     * * `app` - The SLIM application instance that provides the underlying
+     * network transport and session management
+     * * `base_name` - The base name for this service (e.g., org.namespace.service).
+     * This name is used to construct subscription names for RPC methods.
+     *
+     * # Returns
+     * A new RPC server instance wrapped in an Arc for shared ownership
+     */
+    constructor(app, baseName) {
+        super();
+        this[_p] = "Server";
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_server_new(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterTypeName.lower(baseName, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeServerObjectFactory.bless(pointer);
+    }
+    /**
+     * Create a new RPC server with optional connection ID
+     *
+     * The connection ID is used to set up routing before serving RPC requests,
+     * enabling multi-hop RPC calls through specific connections.
+     *
+     * # Arguments
+     * * `app` - The SLIM application instance that provides the underlying
+     * network transport and session management
+     * * `base_name` - The base name for this service (e.g., org.namespace.service).
+     * This name is used to construct subscription names for RPC methods.
+     * * `connection_id` - Optional connection ID for routing setup
+     *
+     * # Returns
+     * A new RPC server instance wrapped in an Arc for shared ownership
+     */
+    static newWithConnection(app, baseName, connectionId) {
+        return FfiConverterTypeServer.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_rpc_fn_constructor_server_new_with_connection(FfiConverterTypeApp.lower(app, nativeModule().rustbuffer_alloc), FfiConverterTypeName.lower(baseName, nativeModule().rustbuffer_alloc), FfiConverterOptionalUInt64.lower(connectionId, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    registerStreamStream(serviceName, methodName, handler) {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_register_stream_stream(uniffiTypeServerObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterTypeStreamStreamHandler.lower(handler, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    registerStreamUnary(serviceName, methodName, handler) {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_register_stream_unary(uniffiTypeServerObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterTypeStreamUnaryHandler.lower(handler, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    registerUnaryStream(serviceName, methodName, handler) {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_register_unary_stream(uniffiTypeServerObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterTypeUnaryStreamHandler.lower(handler, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    registerUnaryUnary(serviceName, methodName, handler) {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_register_unary_unary(uniffiTypeServerObjectFactory.clonePointer(this), FfiConverterString.lower(serviceName, nativeModule().rustbuffer_alloc), FfiConverterString.lower(methodName, nativeModule().rustbuffer_alloc), FfiConverterTypeUnaryUnaryHandler.lower(handler, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Async FFI wrapper for [`Server::serve`].
+     */
+    async serveAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_server_serve_async(uniffiTypeServerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Blocking FFI wrapper for [`Server::serve`].
+     */
+    serveBlocking() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeRpcError.lift.bind(FfiConverterTypeRpcError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_serve_blocking(uniffiTypeServerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Async FFI wrapper for [`Server::shutdown`].
+     */
+    async shutdownAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_rpc_fn_method_server_shutdown_async(uniffiTypeServerObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_rpc_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_rpc_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_rpc_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_);
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Blocking FFI wrapper for [`Server::shutdown`].
+     */
+    shutdownBlocking() {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_rpc_fn_method_server_shutdown_blocking(uniffiTypeServerObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeServerObjectFactory.pointer(this);
+            uniffiTypeServerObjectFactory.freePointer(pointer);
+            uniffiTypeServerObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeServerObjectFactory.isConcreteType(obj_);
+    }
+}
+_p = uniffiTypeNameSymbol;
+const uniffiTypeServerObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeServerObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Server.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Server";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_clone_server(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_slim_rpc_fn_free_server(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Server";
+        },
+    };
+})();
+const FfiConverterTypeServer = new FfiConverterObject(uniffiTypeServerObjectFactory);
+// FfiConverter for ArrayBuffer | undefined
+const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+// FfiConverter for number | undefined
+const FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
+// FfiConverter for Map<string, string>
+const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+// FfiConverter for Map<string, string> | undefined
+const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
+// FfiConverter for Array<NameLike>
+const FfiConverterSequenceTypeName = new FfiConverterArray(FfiConverterTypeName);
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ffi_slim_rpc_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_close_send() !== 8554) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_close_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_close_send_async() !== 61385) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_close_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_recv() !== 22600) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_recv");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_recv_async() !== 32615) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_recv_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_send() !== 6430) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_bidistreamhandler_send_async() !== 15973) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_bidistreamhandler_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_channel_new() !== 61597) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_channel_new");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_channel_new_group() !== 40792) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_channel_new_group");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_channel_new_group_with_connection() !== 4099) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_channel_new_group_with_connection");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_channel_new_with_connection() !== 29890) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_channel_new_with_connection");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_stream_stream() !== 20862) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_stream_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_stream_unary() !== 3931) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_stream_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_unary() !== 45399) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_async() !== 41182) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_stream() !== 1791) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_stream_async() !== 51748) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_multicast_unary_stream_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_stream_stream() !== 17894) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_stream_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_stream_unary() !== 53775) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_stream_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_unary() !== 38109) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_unary_async() !== 4778) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_unary_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_unary_stream() !== 57715) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_unary_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_call_unary_stream_async() !== 60204) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_call_unary_stream_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_close_async() !== 50290) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_close_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_channel_close_blocking() !== 14890) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_channel_close_blocking");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_context_deadline() !== 24900) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_context_deadline");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_context_is_deadline_exceeded() !== 28770) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_context_is_deadline_exceeded");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_context_metadata() !== 27768) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_context_metadata");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_context_remaining_time() !== 37807) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_context_remaining_time");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_context_session_id() !== 20837) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_context_session_id");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_close_send() !== 43173) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_close_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_close_send_async() !== 23110) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_close_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_recv() !== 48140) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_recv");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_recv_async() !== 30100) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_recv_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_send() !== 9203) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_send_async() !== 44011) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastbidistreamhandler_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastresponsereader_next() !== 61701) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastresponsereader_next");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_multicastresponsereader_next_async() !== 39972) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_multicastresponsereader_next_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststream_next() !== 20595) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststream_next");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststream_next_async() !== 54349) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststream_next_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_async() !== 32632) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_stream() !== 54088) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_stream_async() !== 17032) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststreamwriter_finalize_stream_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststreamwriter_send() !== 12390) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststreamwriter_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_requeststreamwriter_send_async() !== 8265) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_requeststreamwriter_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_close() !== 38345) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_close");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_close_async() !== 40886) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_close_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_is_closed() !== 38814) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_is_closed");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_is_closed_async() !== 10047) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_is_closed_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_send() !== 20957) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_send");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_send_async() !== 42417) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_send_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_send_error() !== 19981) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_send_error");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsesink_send_error_async() !== 13763) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsesink_send_error_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsestreamreader_next() !== 36597) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsestreamreader_next");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_responsestreamreader_next_async() !== 61931) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_responsestreamreader_next_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_server_new() !== 34121) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_server_new");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_constructor_server_new_with_connection() !== 20181) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_constructor_server_new_with_connection");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_register_stream_stream() !== 8915) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_register_stream_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_register_stream_unary() !== 1327) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_register_stream_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_register_unary_stream() !== 36089) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_register_unary_stream");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_register_unary_unary() !== 4683) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_register_unary_unary");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_serve_async() !== 31185) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_serve_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_serve_blocking() !== 43892) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_serve_blocking");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_shutdown_async() !== 43873) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_shutdown_async");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_server_shutdown_blocking() !== 33785) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_server_shutdown_blocking");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_streamstreamhandler_handle() !== 2118) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_streamstreamhandler_handle");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_streamunaryhandler_handle() !== 24345) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_streamunaryhandler_handle");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_unarystreamhandler_handle() !== 50805) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_unarystreamhandler_handle");
+    }
+    if (nativeModule().uniffi_slim_rpc_checksum_method_unaryunaryhandler_handle() !== 28269) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_rpc_checksum_method_unaryunaryhandler_handle");
+    }
+    uniffiCallbackInterfaceStreamStreamHandler.register();
+    uniffiCallbackInterfaceStreamUnaryHandler.register();
+    uniffiCallbackInterfaceUnaryStreamHandler.register();
+    uniffiCallbackInterfaceUnaryUnaryHandler.register();
+}
+export default Object.freeze({
+    initialize: uniffiEnsureInitialized,
+    converters: {
+        FfiConverterTypeBidiStreamHandler,
+        FfiConverterTypeChannel,
+        FfiConverterTypeContext,
+        FfiConverterTypeMulticastBidiStreamHandler,
+        FfiConverterTypeMulticastResponseReader,
+        FfiConverterTypeMulticastStreamMessage,
+        FfiConverterTypeRequestStream,
+        FfiConverterTypeRequestStreamWriter,
+        FfiConverterTypeResponseSink,
+        FfiConverterTypeResponseStreamReader,
+        FfiConverterTypeRpcCode,
+        FfiConverterTypeRpcError,
+        FfiConverterTypeRpcMessageContext,
+        FfiConverterTypeRpcMulticastItem,
+        FfiConverterTypeServer,
+        FfiConverterTypeStreamMessage,
+        FfiConverterTypeStreamStreamHandler,
+        FfiConverterTypeStreamUnaryHandler,
+        FfiConverterTypeUnaryStreamHandler,
+        FfiConverterTypeUnaryUnaryHandler,
+    }
+});