@minip2p/react-native 0.7.2 → 0.7.4

package/src/generated/minip2p_ffi_core.ts

@@ -0,0 +1,3939 @@
+// 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 "./minip2p_ffi_core-ffi";
+import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct,
+} from "./minip2p_ffi_core-ffi";
+import { type UniffiByteArray, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol, variantOrdinalSymbol,
+} from "@ubjs/core";
+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;
+
+// Public interface members begin here.
+
+// Hermes (React Native ≥ 0.74) ships TextEncoder and encodeInto, but not
+// TextDecoder. For single-string decode (bytesToString), we polyfill via the
+// C++ string_from_buffer helper using a duck-typed object matching the
+// standard TextDecoder.decode signature. Once Hermes ships a real
+// TextDecoder, the `typeof` check will pick it up automatically.
+//
+// For array-of-strings decode (readStringFromBuffer), we keep a dedicated C++
+// helper: the polyfill path (new Uint8Array view + decode) measured ~40%
+// slower on getStringArray benchmarks than a direct (buf, offset, length)
+// call, due to the per-read view allocation and extra property lookups in
+// string_from_buffer.
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder: { decode(input: UniffiByteArray): string } =
+        typeof TextDecoder !== "undefined"
+            ? new TextDecoder()
+            : {
+                  decode: (bytes: UniffiByteArray) =>
+                      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_from_buffer(
+                          bytes,
+                          undefined as any,
+                      ) as string,
+              };
+    return {
+        // Single-string lower() uses the C++ helper — TextEncoder.encode
+        // measured ~43% slower on takeString benchmarks.
+        stringToBytes: (s: string) =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_buffer(s, undefined as any),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        // Direct C++ call — bypasses uniffiCaller.rustCall() overhead.
+        // Matters for N-element arrays.
+        stringByteLength: (s: string) =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, undefined as any) as number,
+        // Encode directly into the RustBuffer backing store via
+        // TextEncoder.encodeInto — zero intermediate allocation. Replaces
+        // the old C++ write_string_into_buffer helper.
+        writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+            const view = new Uint8Array(
+                buf.arrayBuffer,
+                offset,
+                buf.arrayBuffer.byteLength - offset,
+            );
+            return encoder.encodeInto(s, view).written;
+        },
+        // Dedicated C++ helper — avoids per-read Uint8Array allocation and
+        // the double property-lookup in string_from_buffer.
+        readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer(buf, offset, length) as string,
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * State snapshot of the transport connection selected for a peer.
+ */
+export type ConnectionInfo = {
+    /**
+     * Endpoint-local transport connection id.
+     */
+    connId: bigint,
+    /**
+     * Remote transport address, when recorded.
+     */
+    remoteAddr?: string,
+    /**
+     * Protocols this connection advertised through Identify, once it is
+     * ready (`PeerReady` for this `conn_id`); `None` until then. Readiness,
+     * connection and protocols come from one snapshot, so a ready wait can
+     * trust them together.
+     */
+    readyProtocols?: Array<string>
+}
+
+/**
+ * Generated factory for {@link ConnectionInfo} record objects.
+ */
+export const ConnectionInfo = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ConnectionInfo, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ConnectionInfo>,
+    });
+})();
+
+const FfiConverterTypeConnectionInfo = (() => {
+    type TypeName = ConnectionInfo;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                connId: FfiConverterUInt64.readFromCursor(c),
+                remoteAddr: FfiConverterOptionalString.readFromCursor(c),
+                readyProtocols: FfiConverterOptionalSequenceString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterUInt64.writeIntoCursor(value.connId, c);
+            FfiConverterOptionalString.writeIntoCursor(value.remoteAddr, c);
+            FfiConverterOptionalSequenceString.writeIntoCursor(value.readyProtocols, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt64.allocationSize(value.connId) +
+             FfiConverterOptionalString.allocationSize(value.remoteAddr) +
+             FfiConverterOptionalSequenceString.allocationSize(value.readyProtocols);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Signed-discovery configuration.
+ */
+export type DiscoveryOptions = {
+    /**
+     * Pubsub topic carrying signed discovery beacons.
+     */
+    topic: string,
+    /**
+     * Milliseconds between local beacon announcements.
+     */
+    beaconIntervalMs: bigint,
+    /**
+     * Milliseconds before a signed peer observation expires.
+     */
+    peerTtlMs: bigint,
+    /**
+     * Whether accepted observations may trigger automatic dials.
+     */
+    autoDial: boolean
+}
+
+/**
+ * Generated factory for {@link DiscoveryOptions} record objects.
+ */
+export const DiscoveryOptions = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<DiscoveryOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<DiscoveryOptions>,
+    });
+})();
+
+const FfiConverterTypeDiscoveryOptions = (() => {
+    type TypeName = DiscoveryOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                topic: FfiConverterString.readFromCursor(c),
+                beaconIntervalMs: FfiConverterUInt64.readFromCursor(c),
+                peerTtlMs: FfiConverterUInt64.readFromCursor(c),
+                autoDial: FfiConverterBool.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterString.writeIntoCursor(value.topic, c);
+            FfiConverterUInt64.writeIntoCursor(value.beaconIntervalMs, c);
+            FfiConverterUInt64.writeIntoCursor(value.peerTtlMs, c);
+            FfiConverterBool.writeIntoCursor(value.autoDial, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.topic) +
+             FfiConverterUInt64.allocationSize(value.beaconIntervalMs) +
+             FfiConverterUInt64.allocationSize(value.peerTtlMs) +
+             FfiConverterBool.allocationSize(value.autoDial);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Local-link mDNS discovery configuration.
+ */
+export type MdnsOptions = {
+    /**
+     * Whether IPv6 interfaces and advertisements are enabled.
+     */
+    enableIpv6: boolean,
+    /**
+     * Positive record lifetime advertised on the wire, in milliseconds.
+     */
+    ttlMs: bigint,
+    /**
+     * Steady-state query interval, in milliseconds.
+     */
+    queryIntervalMs: bigint,
+    /**
+     * Maximum DNS/UDP payload emitted by the encoder.
+     */
+    maxPacketBytes: number,
+    /**
+     * Maximum local addresses announced in one response burst.
+     */
+    maxAnnouncedAddrs: number,
+    /**
+     * Interface re-enumeration interval, in milliseconds.
+     */
+    interfaceRefreshMs: bigint,
+    /**
+     * Maximum blocking wait before polling mDNS sockets again.
+     */
+    socketPollIntervalMs: bigint,
+    /**
+     * Whether accepted mDNS observations may trigger automatic dials.
+     */
+    autoDial: boolean
+}
+
+/**
+ * Generated factory for {@link MdnsOptions} record objects.
+ */
+export const MdnsOptions = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<MdnsOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<MdnsOptions>,
+    });
+})();
+
+const FfiConverterTypeMdnsOptions = (() => {
+    type TypeName = MdnsOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                enableIpv6: FfiConverterBool.readFromCursor(c),
+                ttlMs: FfiConverterUInt64.readFromCursor(c),
+                queryIntervalMs: FfiConverterUInt64.readFromCursor(c),
+                maxPacketBytes: FfiConverterUInt32.readFromCursor(c),
+                maxAnnouncedAddrs: FfiConverterUInt32.readFromCursor(c),
+                interfaceRefreshMs: FfiConverterUInt64.readFromCursor(c),
+                socketPollIntervalMs: FfiConverterUInt64.readFromCursor(c),
+                autoDial: FfiConverterBool.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterBool.writeIntoCursor(value.enableIpv6, c);
+            FfiConverterUInt64.writeIntoCursor(value.ttlMs, c);
+            FfiConverterUInt64.writeIntoCursor(value.queryIntervalMs, c);
+            FfiConverterUInt32.writeIntoCursor(value.maxPacketBytes, c);
+            FfiConverterUInt32.writeIntoCursor(value.maxAnnouncedAddrs, c);
+            FfiConverterUInt64.writeIntoCursor(value.interfaceRefreshMs, c);
+            FfiConverterUInt64.writeIntoCursor(value.socketPollIntervalMs, c);
+            FfiConverterBool.writeIntoCursor(value.autoDial, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterBool.allocationSize(value.enableIpv6) +
+             FfiConverterUInt64.allocationSize(value.ttlMs) +
+             FfiConverterUInt64.allocationSize(value.queryIntervalMs) +
+             FfiConverterUInt32.allocationSize(value.maxPacketBytes) +
+             FfiConverterUInt32.allocationSize(value.maxAnnouncedAddrs) +
+             FfiConverterUInt64.allocationSize(value.interfaceRefreshMs) +
+             FfiConverterUInt64.allocationSize(value.socketPollIntervalMs) +
+             FfiConverterBool.allocationSize(value.autoDial);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Configuration used to construct an FFI endpoint.
+ */
+export type EndpointConfig = {
+    /**
+     * Identify agent version, or the crate-derived default when absent.
+     */
+    agentVersion?: string,
+    /**
+     * Relay peer addresses.
+     */
+    relays: Array<string>,
+    /**
+     * AutoNAT server peer addresses.
+     */
+    autonatServers: Array<string>,
+    /**
+     * Listen multiaddresses; each address's shape selects its transport
+     * (`/udp/<port>/quic-v1` or `/tcp/<port>`).
+     *
+     * Absent binds the QUIC dual-stack defaults (`/ip4/0.0.0.0/udp/0/quic-v1`
+     * and `/ip6/::/udp/0/quic-v1`). An explicit empty list is rejected.
+     */
+    listen?: Array<string>,
+    /**
+     * Whether connection attempts must remain relayed.
+     */
+    forceRelay: boolean,
+    /**
+     * Whether unsigned pubsub messages are accepted.
+     */
+    allowUnsigned: boolean,
+    /**
+     * Application protocol ids registered before the endpoint starts.
+     */
+    protocols: Array<string>,
+    /**
+     * Signed-discovery settings, or no discovery when absent.
+     */
+    discovery?: DiscoveryOptions,
+    /**
+     * Local-link mDNS settings, or no mDNS discovery when absent.
+     */
+    mdns?: MdnsOptions
+}
+
+/**
+ * Generated factory for {@link EndpointConfig} record objects.
+ */
+export const EndpointConfig = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<EndpointConfig, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<EndpointConfig>,
+    });
+})();
+
+const FfiConverterTypeEndpointConfig = (() => {
+    type TypeName = EndpointConfig;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                agentVersion: FfiConverterOptionalString.readFromCursor(c),
+                relays: FfiConverterSequenceString.readFromCursor(c),
+                autonatServers: FfiConverterSequenceString.readFromCursor(c),
+                listen: FfiConverterOptionalSequenceString.readFromCursor(c),
+                forceRelay: FfiConverterBool.readFromCursor(c),
+                allowUnsigned: FfiConverterBool.readFromCursor(c),
+                protocols: FfiConverterSequenceString.readFromCursor(c),
+                discovery: FfiConverterOptionalTypeDiscoveryOptions.readFromCursor(c),
+                mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
+            FfiConverterSequenceString.writeIntoCursor(value.relays, c);
+            FfiConverterSequenceString.writeIntoCursor(value.autonatServers, c);
+            FfiConverterOptionalSequenceString.writeIntoCursor(value.listen, c);
+            FfiConverterBool.writeIntoCursor(value.forceRelay, c);
+            FfiConverterBool.writeIntoCursor(value.allowUnsigned, c);
+            FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+            FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
+            FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalString.allocationSize(value.agentVersion) +
+             FfiConverterSequenceString.allocationSize(value.relays) +
+             FfiConverterSequenceString.allocationSize(value.autonatServers) +
+             FfiConverterOptionalSequenceString.allocationSize(value.listen) +
+             FfiConverterBool.allocationSize(value.forceRelay) +
+             FfiConverterBool.allocationSize(value.allowUnsigned) +
+             FfiConverterSequenceString.allocationSize(value.protocols) +
+             FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) +
+             FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Foreign-friendly snapshot of a peer's Identify message.
+ */
+export type IdentifyInfo = {
+    /**
+     * Protobuf-encoded libp2p public key, when supplied.
+     */
+    publicKey?: ArrayBuffer,
+    /**
+     * Listen addresses advertised by the peer.
+     */
+    listenAddrs: Array<string>,
+    /**
+     * Protocol ids advertised by the peer.
+     */
+    protocols: Array<string>,
+    /**
+     * Address the peer observed for this endpoint, when supplied.
+     */
+    observedAddr?: string,
+    /**
+     * Remote libp2p protocol version, when supplied.
+     */
+    protocolVersion?: string,
+    /**
+     * Remote agent version, when supplied.
+     */
+    agentVersion?: string
+}
+
+/**
+ * Generated factory for {@link IdentifyInfo} record objects.
+ */
+export const IdentifyInfo = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<IdentifyInfo, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<IdentifyInfo>,
+    });
+})();
+
+const FfiConverterTypeIdentifyInfo = (() => {
+    type TypeName = IdentifyInfo;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                publicKey: FfiConverterOptionalBytes.readFromCursor(c),
+                listenAddrs: FfiConverterSequenceString.readFromCursor(c),
+                protocols: FfiConverterSequenceString.readFromCursor(c),
+                observedAddr: FfiConverterOptionalString.readFromCursor(c),
+                protocolVersion: FfiConverterOptionalString.readFromCursor(c),
+                agentVersion: FfiConverterOptionalString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalBytes.writeIntoCursor(value.publicKey, c);
+            FfiConverterSequenceString.writeIntoCursor(value.listenAddrs, c);
+            FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+            FfiConverterOptionalString.writeIntoCursor(value.observedAddr, c);
+            FfiConverterOptionalString.writeIntoCursor(value.protocolVersion, c);
+            FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalBytes.allocationSize(value.publicKey) +
+             FfiConverterSequenceString.allocationSize(value.listenAddrs) +
+             FfiConverterSequenceString.allocationSize(value.protocols) +
+             FfiConverterOptionalString.allocationSize(value.observedAddr) +
+             FfiConverterOptionalString.allocationSize(value.protocolVersion) +
+             FfiConverterOptionalString.allocationSize(value.agentVersion);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * One peer in the shared discovery address book.
+ */
+export type KnownPeerInfo = {
+    /**
+     * Discovered peer.
+     */
+    peerId: string,
+    /**
+     * Merged dial-order addresses.
+     */
+    addrs: Array<string>,
+    /**
+     * Addresses authenticated by signed beacons.
+     */
+    beaconAddrs: Array<string>,
+    /**
+     * Addresses learned from unauthenticated mDNS.
+     */
+    mdnsAddrs: Array<string>,
+    /**
+     * Age of the most recent signed beacon.
+     */
+    beaconLastSeenAgeMs?: bigint,
+    /**
+     * Age of the most recent mDNS observation.
+     */
+    mdnsLastSeenAgeMs?: bigint,
+    /**
+     * Whether the endpoint currently has a connection to this peer.
+     */
+    connected: boolean
+}
+
+/**
+ * Generated factory for {@link KnownPeerInfo} record objects.
+ */
+export const KnownPeerInfo = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<KnownPeerInfo, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<KnownPeerInfo>,
+    });
+})();
+
+const FfiConverterTypeKnownPeerInfo = (() => {
+    type TypeName = KnownPeerInfo;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                peerId: FfiConverterString.readFromCursor(c),
+                addrs: FfiConverterSequenceString.readFromCursor(c),
+                beaconAddrs: FfiConverterSequenceString.readFromCursor(c),
+                mdnsAddrs: FfiConverterSequenceString.readFromCursor(c),
+                beaconLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                mdnsLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                connected: FfiConverterBool.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterString.writeIntoCursor(value.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(value.addrs, c);
+            FfiConverterSequenceString.writeIntoCursor(value.beaconAddrs, c);
+            FfiConverterSequenceString.writeIntoCursor(value.mdnsAddrs, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.beaconLastSeenAgeMs, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.mdnsLastSeenAgeMs, c);
+            FfiConverterBool.writeIntoCursor(value.connected, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.peerId) +
+             FfiConverterSequenceString.allocationSize(value.addrs) +
+             FfiConverterSequenceString.allocationSize(value.beaconAddrs) +
+             FfiConverterSequenceString.allocationSize(value.mdnsAddrs) +
+             FfiConverterOptionalUInt64.allocationSize(value.beaconLastSeenAgeMs) +
+             FfiConverterOptionalUInt64.allocationSize(value.mdnsLastSeenAgeMs) +
+             FfiConverterBool.allocationSize(value.connected);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Full identity allocated for an outbound application stream.
+ */
+export type OpenStreamResult = {
+    /**
+     * Transport connection carrying the stream.
+     */
+    connId: bigint,
+    /**
+     * Opaque stream id.
+     */
+    streamId: bigint
+}
+
+/**
+ * Generated factory for {@link OpenStreamResult} record objects.
+ */
+export const OpenStreamResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<OpenStreamResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<OpenStreamResult>,
+    });
+})();
+
+const FfiConverterTypeOpenStreamResult = (() => {
+    type TypeName = OpenStreamResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                connId: FfiConverterUInt64.readFromCursor(c),
+                streamId: FfiConverterUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterUInt64.writeIntoCursor(value.connId, c);
+            FfiConverterUInt64.writeIntoCursor(value.streamId, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt64.allocationSize(value.connId) +
+             FfiConverterUInt64.allocationSize(value.streamId);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Snapshot of the active inbound relay reservation.
+ */
+export type RelayReservationInfo = {
+    /**
+     * Relay holding the reservation.
+     */
+    relayPeerId: string,
+    /**
+     * Absolute relay-reported expiry, when present.
+     */
+    expiresUnixSecs?: bigint
+}
+
+/**
+ * Generated factory for {@link RelayReservationInfo} record objects.
+ */
+export const RelayReservationInfo = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<RelayReservationInfo, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<RelayReservationInfo>,
+    });
+})();
+
+const FfiConverterTypeRelayReservationInfo = (() => {
+    type TypeName = RelayReservationInfo;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                relayPeerId: FfiConverterString.readFromCursor(c),
+                expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterString.writeIntoCursor(value.relayPeerId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.expiresUnixSecs, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.relayPeerId) +
+             FfiConverterOptionalUInt64.allocationSize(value.expiresUnixSecs);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+// Enum: ConnectTarget
+export enum ConnectTarget_Tags {
+    Peer = "Peer",
+    Addresses = "Addresses"
+}
+/**
+ * What a foreign runtime supplies to start one Connection attempt.
+ *
+ * Validation for every form lives in this module, once; binding shells only
+ * adapt the shape to their toolchain.
+ */
+export const ConnectTarget = (() => {
+
+    type Peer__interface = {
+        tag: ConnectTarget_Tags.Peer;
+        inner:
+Readonly<{peerId: string}>
+    };
+    /**
+     * Peer ID only: the endpoint applies its discovery-book and relay
+     * policy.
+     */
+    class Peer_ extends UniffiEnum implements Peer__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
+        readonly tag = ConnectTarget_Tags.Peer;
+        readonly inner:
+Readonly<{peerId: string}>;
+        constructor(
+inner: {peerId: string }) {
+            super("ConnectTarget", "Peer");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string }): Peer_ {
+            return new Peer_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Peer_ {
+            return obj.tag === ConnectTarget_Tags.Peer;
+        }
+
+    }
+
+    type Addresses__interface = {
+        tag: ConnectTarget_Tags.Addresses;
+        inner:
+Readonly<{addresses: Array<string>}>
+    };
+    /**
+     * One or more complete direct peer addresses that all name the same
+     * peer. One address is the single-address form.
+     */
+    class Addresses_ extends UniffiEnum implements Addresses__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
+        readonly tag = ConnectTarget_Tags.Addresses;
+        readonly inner:
+Readonly<{addresses: Array<string>}>;
+        constructor(
+inner: {addresses: Array<string> }) {
+            super("ConnectTarget", "Addresses");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {addresses: Array<string> }): Addresses_ {
+            return new Addresses_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Addresses_ {
+            return obj.tag === ConnectTarget_Tags.Addresses;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is ConnectTarget {
+        return obj[uniffiTypeNameSymbol] === "ConnectTarget";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Peer: Peer_,
+  Addresses: Addresses_
+    });
+
+})();
+/**
+ * What a foreign runtime supplies to start one Connection attempt.
+ *
+ * Validation for every form lives in this module, once; binding shells only
+ * adapt the shape to their toolchain.
+ */
+export type ConnectTarget = InstanceType<
+    typeof ConnectTarget['Peer' | 'Addresses']
+>;
+
+// FfiConverter for enum ConnectTarget
+const FfiConverterTypeConnectTarget = (() => {
+    type TypeName = ConnectTarget;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new ConnectTarget.Peer({peerId: FfiConverterString.readFromCursor(c) });
+                case 2: return new ConnectTarget.Addresses({addresses: FfiConverterSequenceString.readFromCursor(c) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case ConnectTarget_Tags.Peer: {
+                    c.writeI32(1);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    return;
+                }
+                case ConnectTarget_Tags.Addresses: {
+                    c.writeI32(2);
+                    const inner = value.inner;
+                    FfiConverterSequenceString.writeIntoCursor(inner.addresses, c);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ConnectTarget_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case ConnectTarget_Tags.Peer: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    return size;
+                }
+                case ConnectTarget_Tags.Addresses: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterSequenceString.allocationSize(inner.addresses);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Source that contributed a discovery observation.
+ */
+export enum DiscoverySource {
+    /**
+     * Public-key-authenticated signed beacon.
+     */
+    SignedBeacon,
+    /**
+     * Unauthenticated local-link mDNS observation.
+     */
+    Mdns
+}
+
+const FfiConverterTypeDiscoverySource = (() => {
+    type TypeName = DiscoverySource;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return DiscoverySource.SignedBeacon;
+                case 2: return DiscoverySource.Mdns;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case DiscoverySource.SignedBeacon: return c.writeI32(1);
+                case DiscoverySource.Mdns: return c.writeI32(2);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Category of a fatal background-driver failure.
+ */
+export enum DriverFailureKind {
+    /**
+     * The transport driver failed.
+     */
+    Transport,
+    /**
+     * The swarm driver failed.
+     */
+    Swarm,
+    /**
+     * An internal driver invariant failed.
+     */
+    Invariant,
+    /**
+     * The background pump panicked.
+     */
+    Panic
+}
+
+const FfiConverterTypeDriverFailureKind = (() => {
+    type TypeName = DriverFailureKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return DriverFailureKind.Transport;
+                case 2: return DriverFailureKind.Swarm;
+                case 3: return DriverFailureKind.Invariant;
+                case 4: return DriverFailureKind.Panic;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case DriverFailureKind.Transport: return c.writeI32(1);
+                case DriverFailureKind.Swarm: return c.writeI32(2);
+                case DriverFailureKind.Invariant: return c.writeI32(3);
+                case DriverFailureKind.Panic: return c.writeI32(4);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Category of a non-fatal endpoint runtime error.
+ */
+export enum EndpointErrorKind {
+    /**
+     * Underlying transport operation failed.
+     */
+    Transport,
+    /**
+     * Multistream negotiation failed.
+     */
+    Multistream,
+    /**
+     * Identify protocol failed.
+     */
+    Identify,
+    /**
+     * Ping protocol failed.
+     */
+    Ping,
+    /**
+     * Identify stream setup was rejected.
+     */
+    IdentifyStreamRejected,
+    /**
+     * Outbound stream opening failed.
+     */
+    OpenStreamFailed,
+    /**
+     * The remote does not support a requested protocol.
+     */
+    UnsupportedProtocol,
+    /**
+     * The swarm driver contract failed.
+     */
+    Driver
+}
+
+const FfiConverterTypeEndpointErrorKind = (() => {
+    type TypeName = EndpointErrorKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return EndpointErrorKind.Transport;
+                case 2: return EndpointErrorKind.Multistream;
+                case 3: return EndpointErrorKind.Identify;
+                case 4: return EndpointErrorKind.Ping;
+                case 5: return EndpointErrorKind.IdentifyStreamRejected;
+                case 6: return EndpointErrorKind.OpenStreamFailed;
+                case 7: return EndpointErrorKind.UnsupportedProtocol;
+                case 8: return EndpointErrorKind.Driver;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case EndpointErrorKind.Transport: return c.writeI32(1);
+                case EndpointErrorKind.Multistream: return c.writeI32(2);
+                case EndpointErrorKind.Identify: return c.writeI32(3);
+                case EndpointErrorKind.Ping: return c.writeI32(4);
+                case EndpointErrorKind.IdentifyStreamRejected: return c.writeI32(5);
+                case EndpointErrorKind.OpenStreamFailed: return c.writeI32(6);
+                case EndpointErrorKind.UnsupportedProtocol: return c.writeI32(7);
+                case EndpointErrorKind.Driver: return c.writeI32(8);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+// Error type: FfiError
+export enum FfiError_Tags {
+    AlreadyStarted = "AlreadyStarted",
+    Stopped = "Stopped",
+    InvalidConfig = "InvalidConfig",
+    InvalidKey = "InvalidKey",
+    InvalidPeerId = "InvalidPeerId",
+    InvalidAddress = "InvalidAddress",
+    InvalidTopic = "InvalidTopic",
+    NotPermitted = "NotPermitted",
+    Backpressure = "Backpressure",
+    MessageTooLarge = "MessageTooLarge",
+    Transport = "Transport",
+    InvalidState = "InvalidState",
+    Internal = "Internal"
+}
+/**
+ * An error returned by a synchronous FFI operation.
+ */
+export const FfiError = (() => {
+
+    type AlreadyStarted__interface = {
+        tag: FfiError_Tags.AlreadyStarted
+    };
+    /**
+     * The endpoint's background driver was already started.
+     */
+    class AlreadyStarted_ extends UniffiError implements AlreadyStarted__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.AlreadyStarted;
+        constructor() {
+            super("FfiError", "AlreadyStarted");
+        }
+
+        static new(): AlreadyStarted_ {
+            return new AlreadyStarted_();
+        }
+
+        static instanceOf(obj: any): obj is AlreadyStarted_ {
+            return obj.tag === FfiError_Tags.AlreadyStarted;
+        }
+        static hasInner(obj: any): obj is AlreadyStarted_ {
+            return false;
+        }
+
+    }
+
+    type Stopped__interface = {
+        tag: FfiError_Tags.Stopped
+    };
+    /**
+     * The endpoint has stopped and cannot be restarted.
+     */
+    class Stopped_ extends UniffiError implements Stopped__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.Stopped;
+        constructor() {
+            super("FfiError", "Stopped");
+        }
+
+        static new(): Stopped_ {
+            return new Stopped_();
+        }
+
+        static instanceOf(obj: any): obj is Stopped_ {
+            return obj.tag === FfiError_Tags.Stopped;
+        }
+        static hasInner(obj: any): obj is Stopped_ {
+            return false;
+        }
+
+    }
+
+    type InvalidConfig__interface = {
+        tag: FfiError_Tags.InvalidConfig;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * Endpoint configuration was internally inconsistent.
+     */
+    class InvalidConfig_ extends UniffiError implements InvalidConfig__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidConfig;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidConfig");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidConfig_ {
+            return new InvalidConfig_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidConfig_ {
+            return obj.tag === FfiError_Tags.InvalidConfig;
+        }
+        static hasInner(obj: any): obj is InvalidConfig_ {
+            return InvalidConfig_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidConfig_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type InvalidKey__interface = {
+        tag: FfiError_Tags.InvalidKey;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * Secret key material was not exactly 32 bytes.
+     */
+    class InvalidKey_ extends UniffiError implements InvalidKey__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidKey;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidKey");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidKey_ {
+            return new InvalidKey_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidKey_ {
+            return obj.tag === FfiError_Tags.InvalidKey;
+        }
+        static hasInner(obj: any): obj is InvalidKey_ {
+            return InvalidKey_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidKey_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type InvalidPeerId__interface = {
+        tag: FfiError_Tags.InvalidPeerId;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * A peer ID could not be parsed.
+     */
+    class InvalidPeerId_ extends UniffiError implements InvalidPeerId__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidPeerId;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidPeerId");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidPeerId_ {
+            return new InvalidPeerId_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidPeerId_ {
+            return obj.tag === FfiError_Tags.InvalidPeerId;
+        }
+        static hasInner(obj: any): obj is InvalidPeerId_ {
+            return InvalidPeerId_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidPeerId_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type InvalidAddress__interface = {
+        tag: FfiError_Tags.InvalidAddress;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * A multiaddress or peer address could not be parsed.
+     */
+    class InvalidAddress_ extends UniffiError implements InvalidAddress__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidAddress;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidAddress");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidAddress_ {
+            return new InvalidAddress_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidAddress_ {
+            return obj.tag === FfiError_Tags.InvalidAddress;
+        }
+        static hasInner(obj: any): obj is InvalidAddress_ {
+            return InvalidAddress_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidAddress_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type InvalidTopic__interface = {
+        tag: FfiError_Tags.InvalidTopic;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * A pubsub topic failed validation.
+     */
+    class InvalidTopic_ extends UniffiError implements InvalidTopic__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidTopic;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidTopic");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidTopic_ {
+            return new InvalidTopic_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidTopic_ {
+            return obj.tag === FfiError_Tags.InvalidTopic;
+        }
+        static hasInner(obj: any): obj is InvalidTopic_ {
+            return InvalidTopic_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidTopic_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type NotPermitted__interface = {
+        tag: FfiError_Tags.NotPermitted;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * The operation is valid but reserved by another endpoint subsystem.
+     */
+    class NotPermitted_ extends UniffiError implements NotPermitted__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.NotPermitted;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "NotPermitted");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): NotPermitted_ {
+            return new NotPermitted_(inner);
+        }
+
+        static instanceOf(obj: any): obj is NotPermitted_ {
+            return obj.tag === FfiError_Tags.NotPermitted;
+        }
+        static hasInner(obj: any): obj is NotPermitted_ {
+            return NotPermitted_.instanceOf(obj);
+        }
+
+        static getInner(obj: NotPermitted_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type Backpressure__interface = {
+        tag: FfiError_Tags.Backpressure
+    };
+    /**
+     * A bounded outbound queue is full.
+     */
+    class Backpressure_ extends UniffiError implements Backpressure__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.Backpressure;
+        constructor() {
+            super("FfiError", "Backpressure");
+        }
+
+        static new(): Backpressure_ {
+            return new Backpressure_();
+        }
+
+        static instanceOf(obj: any): obj is Backpressure_ {
+            return obj.tag === FfiError_Tags.Backpressure;
+        }
+        static hasInner(obj: any): obj is Backpressure_ {
+            return false;
+        }
+
+    }
+
+    type MessageTooLarge__interface = {
+        tag: FfiError_Tags.MessageTooLarge
+    };
+    /**
+     * A pubsub message exceeds the protocol limit.
+     */
+    class MessageTooLarge_ extends UniffiError implements MessageTooLarge__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.MessageTooLarge;
+        constructor() {
+            super("FfiError", "MessageTooLarge");
+        }
+
+        static new(): MessageTooLarge_ {
+            return new MessageTooLarge_();
+        }
+
+        static instanceOf(obj: any): obj is MessageTooLarge_ {
+            return obj.tag === FfiError_Tags.MessageTooLarge;
+        }
+        static hasInner(obj: any): obj is MessageTooLarge_ {
+            return false;
+        }
+
+    }
+
+    type Transport__interface = {
+        tag: FfiError_Tags.Transport;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * A synchronous transport operation failed.
+     */
+    class Transport_ extends UniffiError implements Transport__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.Transport;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "Transport");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): Transport_ {
+            return new Transport_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Transport_ {
+            return obj.tag === FfiError_Tags.Transport;
+        }
+        static hasInner(obj: any): obj is Transport_ {
+            return Transport_.instanceOf(obj);
+        }
+
+        static getInner(obj: Transport_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type InvalidState__interface = {
+        tag: FfiError_Tags.InvalidState;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * The operation is unavailable in the endpoint's current lifecycle state.
+     */
+    class InvalidState_ extends UniffiError implements InvalidState__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.InvalidState;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "InvalidState");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): InvalidState_ {
+            return new InvalidState_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InvalidState_ {
+            return obj.tag === FfiError_Tags.InvalidState;
+        }
+        static hasInner(obj: any): obj is InvalidState_ {
+            return InvalidState_.instanceOf(obj);
+        }
+
+        static getInner(obj: InvalidState_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    type Internal__interface = {
+        tag: FfiError_Tags.Internal;
+        inner:
+Readonly<{detail: string}>
+    };
+    /**
+     * An internal invariant or unexpected construction path failed.
+     */
+    class Internal_ extends UniffiError implements Internal__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "FfiError";
+        readonly tag = FfiError_Tags.Internal;
+        readonly inner:
+Readonly<{detail: string}>;
+        constructor(
+inner: {detail: string }) {
+            super("FfiError", "Internal");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {detail: string }): Internal_ {
+            return new Internal_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Internal_ {
+            return obj.tag === FfiError_Tags.Internal;
+        }
+        static hasInner(obj: any): obj is Internal_ {
+            return Internal_.instanceOf(obj);
+        }
+
+        static getInner(obj: Internal_):
+Readonly<{detail: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is FfiError {
+        return obj[uniffiTypeNameSymbol] === "FfiError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  AlreadyStarted: AlreadyStarted_,
+  Stopped: Stopped_,
+  InvalidConfig: InvalidConfig_,
+  InvalidKey: InvalidKey_,
+  InvalidPeerId: InvalidPeerId_,
+  InvalidAddress: InvalidAddress_,
+  InvalidTopic: InvalidTopic_,
+  NotPermitted: NotPermitted_,
+  Backpressure: Backpressure_,
+  MessageTooLarge: MessageTooLarge_,
+  Transport: Transport_,
+  InvalidState: InvalidState_,
+  Internal: Internal_
+    });
+
+})();
+/**
+ * An error returned by a synchronous FFI operation.
+ */
+export type FfiError = InstanceType<
+    typeof FfiError['AlreadyStarted' | 'Stopped' | 'InvalidConfig' | 'InvalidKey' | 'InvalidPeerId' | 'InvalidAddress' | 'InvalidTopic' | 'NotPermitted' | 'Backpressure' | 'MessageTooLarge' | 'Transport' | 'InvalidState' | 'Internal']
+>;
+
+// FfiConverter for enum FfiError
+const FfiConverterTypeFfiError = (() => {
+    type TypeName = FfiError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new FfiError.AlreadyStarted();
+                case 2: return new FfiError.Stopped();
+                case 3: return new FfiError.InvalidConfig({detail: FfiConverterString.readFromCursor(c) });
+                case 4: return new FfiError.InvalidKey({detail: FfiConverterString.readFromCursor(c) });
+                case 5: return new FfiError.InvalidPeerId({detail: FfiConverterString.readFromCursor(c) });
+                case 6: return new FfiError.InvalidAddress({detail: FfiConverterString.readFromCursor(c) });
+                case 7: return new FfiError.InvalidTopic({detail: FfiConverterString.readFromCursor(c) });
+                case 8: return new FfiError.NotPermitted({detail: FfiConverterString.readFromCursor(c) });
+                case 9: return new FfiError.Backpressure();
+                case 10: return new FfiError.MessageTooLarge();
+                case 11: return new FfiError.Transport({detail: FfiConverterString.readFromCursor(c) });
+                case 12: return new FfiError.InvalidState({detail: FfiConverterString.readFromCursor(c) });
+                case 13: return new FfiError.Internal({detail: FfiConverterString.readFromCursor(c) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case FfiError_Tags.AlreadyStarted: {
+                    c.writeI32(1);
+                    return;
+                }
+                case FfiError_Tags.Stopped: {
+                    c.writeI32(2);
+                    return;
+                }
+                case FfiError_Tags.InvalidConfig: {
+                    c.writeI32(3);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.InvalidKey: {
+                    c.writeI32(4);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.InvalidPeerId: {
+                    c.writeI32(5);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.InvalidAddress: {
+                    c.writeI32(6);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.InvalidTopic: {
+                    c.writeI32(7);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.NotPermitted: {
+                    c.writeI32(8);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.Backpressure: {
+                    c.writeI32(9);
+                    return;
+                }
+                case FfiError_Tags.MessageTooLarge: {
+                    c.writeI32(10);
+                    return;
+                }
+                case FfiError_Tags.Transport: {
+                    c.writeI32(11);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.InvalidState: {
+                    c.writeI32(12);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case FfiError_Tags.Internal: {
+                    c.writeI32(13);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                default:
+                    // Throwing from here means that FfiError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case FfiError_Tags.AlreadyStarted: {
+                    return 4;
+                }
+                case FfiError_Tags.Stopped: {
+                    return 4;
+                }
+                case FfiError_Tags.InvalidConfig: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.InvalidKey: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.InvalidPeerId: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.InvalidAddress: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.InvalidTopic: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.NotPermitted: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.Backpressure: {
+                    return 4;
+                }
+                case FfiError_Tags.MessageTooLarge: {
+                    return 4;
+                }
+                case FfiError_Tags.Transport: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.InvalidState: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case FfiError_Tags.Internal: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Category of a failed NAT connection attempt.
+ */
+export enum NatErrorKind {
+    /**
+     * No usable direct or relayed path exists.
+     */
+    NoPathAvailable,
+    /**
+     * The connection attempt timed out.
+     */
+    Timeout,
+    /**
+     * A transport dial failed.
+     */
+    DialFailed,
+    /**
+     * A traversal protocol exchange failed.
+     */
+    Protocol,
+    /**
+     * A relay refused the circuit.
+     */
+    RelayRefused
+}
+
+const FfiConverterTypeNatErrorKind = (() => {
+    type TypeName = NatErrorKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return NatErrorKind.NoPathAvailable;
+                case 2: return NatErrorKind.Timeout;
+                case 3: return NatErrorKind.DialFailed;
+                case 4: return NatErrorKind.Protocol;
+                case 5: return NatErrorKind.RelayRefused;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case NatErrorKind.NoPathAvailable: return c.writeI32(1);
+                case NatErrorKind.Timeout: return c.writeI32(2);
+                case NatErrorKind.DialFailed: return c.writeI32(3);
+                case NatErrorKind.Protocol: return c.writeI32(4);
+                case NatErrorKind.RelayRefused: return c.writeI32(5);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Coarse local reachability state.
+ */
+export enum Reachability {
+    /**
+     * Not enough evidence is available.
+     */
+    Unknown,
+    /**
+     * The endpoint is directly reachable.
+     */
+    Public,
+    /**
+     * The endpoint needs traversal or relay assistance.
+     */
+    Private
+}
+
+const FfiConverterTypeReachability = (() => {
+    type TypeName = Reachability;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return Reachability.Unknown;
+                case 2: return Reachability.Public;
+                case 3: return Reachability.Private;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case Reachability.Unknown: return c.writeI32(1);
+                case Reachability.Public: return c.writeI32(2);
+                case Reachability.Private: return c.writeI32(3);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+// Enum: PathKind
+export enum PathKind_Tags {
+    DirectDialed = "DirectDialed",
+    DirectPunched = "DirectPunched",
+    Relayed = "Relayed"
+}
+/**
+ * Kind of usable connection path.
+ */
+export const PathKind = (() => {
+
+    type DirectDialed__interface = {
+        tag: PathKind_Tags.DirectDialed
+    };
+    /**
+     * A known address was dialed directly.
+     */
+    class DirectDialed_ extends UniffiEnum implements DirectDialed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.DirectDialed;
+        constructor() {
+            super("PathKind", "DirectDialed");
+        }
+
+        static new(): DirectDialed_ {
+            return new DirectDialed_();
+        }
+
+        static instanceOf(obj: any): obj is DirectDialed_ {
+            return obj.tag === PathKind_Tags.DirectDialed;
+        }
+
+    }
+
+    type DirectPunched__interface = {
+        tag: PathKind_Tags.DirectPunched
+    };
+    /**
+     * A direct path was established by hole punching.
+     */
+    class DirectPunched_ extends UniffiEnum implements DirectPunched__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.DirectPunched;
+        constructor() {
+            super("PathKind", "DirectPunched");
+        }
+
+        static new(): DirectPunched_ {
+            return new DirectPunched_();
+        }
+
+        static instanceOf(obj: any): obj is DirectPunched_ {
+            return obj.tag === PathKind_Tags.DirectPunched;
+        }
+
+    }
+
+    type Relayed__interface = {
+        tag: PathKind_Tags.Relayed;
+        inner:
+Readonly<{relayPeerId: string}>
+    };
+    /**
+     * Traffic is carried through a relay.
+     */
+    class Relayed_ extends UniffiEnum implements Relayed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.Relayed;
+        readonly inner:
+Readonly<{relayPeerId: string}>;
+        constructor(
+inner: {relayPeerId: string }) {
+            super("PathKind", "Relayed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {relayPeerId: string }): Relayed_ {
+            return new Relayed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Relayed_ {
+            return obj.tag === PathKind_Tags.Relayed;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is PathKind {
+        return obj[uniffiTypeNameSymbol] === "PathKind";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  DirectDialed: DirectDialed_,
+  DirectPunched: DirectPunched_,
+  Relayed: Relayed_
+    });
+
+})();
+/**
+ * Kind of usable connection path.
+ */
+export type PathKind = InstanceType<
+    typeof PathKind['DirectDialed' | 'DirectPunched' | 'Relayed']
+>;
+
+// FfiConverter for enum PathKind
+const FfiConverterTypePathKind = (() => {
+    type TypeName = PathKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new PathKind.DirectDialed();
+                case 2: return new PathKind.DirectPunched();
+                case 3: return new PathKind.Relayed({relayPeerId: FfiConverterString.readFromCursor(c) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case PathKind_Tags.DirectDialed: {
+                    c.writeI32(1);
+                    return;
+                }
+                case PathKind_Tags.DirectPunched: {
+                    c.writeI32(2);
+                    return;
+                }
+                case PathKind_Tags.Relayed: {
+                    c.writeI32(3);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+                    return;
+                }
+                default:
+                    // Throwing from here means that PathKind_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case PathKind_Tags.DirectDialed: {
+                    return 4;
+                }
+                case PathKind_Tags.DirectPunched: {
+                    return 4;
+                }
+                case PathKind_Tags.Relayed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.relayPeerId);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+// Enum: P2pEvent
+export enum P2pEvent_Tags {
+    EventsDropped = "EventsDropped",
+    DriverFailed = "DriverFailed",
+    ConnectionEstablished = "ConnectionEstablished",
+    ConnectionClosed = "ConnectionClosed",
+    ConnectionReplaced = "ConnectionReplaced",
+    PeerReady = "PeerReady",
+    IdentifyReceived = "IdentifyReceived",
+    PingRttMeasured = "PingRttMeasured",
+    PingTimeout = "PingTimeout",
+    StreamReady = "StreamReady",
+    StreamData = "StreamData",
+    StreamRemoteWriteClosed = "StreamRemoteWriteClosed",
+    StreamClosed = "StreamClosed",
+    EndpointError = "EndpointError",
+    ReachabilityChanged = "ReachabilityChanged",
+    PublicAddressesChanged = "PublicAddressesChanged",
+    RelayReserved = "RelayReserved",
+    RelayReservationLost = "RelayReservationLost",
+    PathEstablished = "PathEstablished",
+    InboundPathEstablished = "InboundPathEstablished",
+    PathUpgraded = "PathUpgraded",
+    HolePunchFailed = "HolePunchFailed",
+    ConnectFailed = "ConnectFailed",
+    ConnectCancelled = "ConnectCancelled",
+    InboundDirectUpgrade = "InboundDirectUpgrade",
+    Message = "Message",
+    PeerSubscribed = "PeerSubscribed",
+    PeerUnsubscribed = "PeerUnsubscribed",
+    GossipsubOutboundFailure = "GossipsubOutboundFailure",
+    GossipsubProtocolViolation = "GossipsubProtocolViolation",
+    PeerDiscovered = "PeerDiscovered",
+    PeerUpdated = "PeerUpdated",
+    PeerExpired = "PeerExpired",
+    DiscoveryDialFailed = "DiscoveryDialFailed",
+    DiscoveryProtocolViolation = "DiscoveryProtocolViolation"
+}
+/**
+ * Event delivered by the native endpoint driver.
+ */
+export const P2pEvent = (() => {
+
+    type EventsDropped__interface = {
+        tag: P2pEvent_Tags.EventsDropped;
+        inner:
+Readonly<{dropped: bigint; totalDropped: bigint; terminalConnectIds: Array<bigint>}>
+    };
+    /**
+     * Native event carry overflow discarded source events.
+     */
+    class EventsDropped_ extends UniffiEnum implements EventsDropped__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.EventsDropped;
+        readonly inner:
+Readonly<{dropped: bigint; totalDropped: bigint; terminalConnectIds: Array<bigint>}>;
+        constructor(
+inner: {dropped: bigint; totalDropped: bigint; terminalConnectIds: Array<bigint> }) {
+            super("P2pEvent", "EventsDropped");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {dropped: bigint; totalDropped: bigint; terminalConnectIds: Array<bigint> }): EventsDropped_ {
+            return new EventsDropped_(inner);
+        }
+
+        static instanceOf(obj: any): obj is EventsDropped_ {
+            return obj.tag === P2pEvent_Tags.EventsDropped;
+        }
+
+    }
+
+    type DriverFailed__interface = {
+        tag: P2pEvent_Tags.DriverFailed;
+        inner:
+Readonly<{kind: DriverFailureKind; detail: string}>
+    };
+    /**
+     * The background driver terminated after a fatal failure.
+     */
+    class DriverFailed_ extends UniffiEnum implements DriverFailed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.DriverFailed;
+        readonly inner:
+Readonly<{kind: DriverFailureKind; detail: string}>;
+        constructor(
+inner: {kind: DriverFailureKind; detail: string }) {
+            super("P2pEvent", "DriverFailed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {kind: DriverFailureKind; detail: string }): DriverFailed_ {
+            return new DriverFailed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is DriverFailed_ {
+            return obj.tag === P2pEvent_Tags.DriverFailed;
+        }
+
+    }
+
+    type ConnectionEstablished__interface = {
+        tag: P2pEvent_Tags.ConnectionEstablished;
+        inner:
+Readonly<{peerId: string; connId: bigint}>
+    };
+    /**
+     * A peer went from disconnected to connected over a verified connection.
+     */
+    class ConnectionEstablished_ extends UniffiEnum implements ConnectionEstablished__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ConnectionEstablished;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint}>;
+        constructor(
+inner: {peerId: string; connId: bigint }) {
+            super("P2pEvent", "ConnectionEstablished");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint }): ConnectionEstablished_ {
+            return new ConnectionEstablished_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ConnectionEstablished_ {
+            return obj.tag === P2pEvent_Tags.ConnectionEstablished;
+        }
+
+    }
+
+    type ConnectionClosed__interface = {
+        tag: P2pEvent_Tags.ConnectionClosed;
+        inner:
+Readonly<{peerId: string; connId: bigint}>
+    };
+    /**
+     * The peer's last connection closed; the peer is now disconnected.
+     */
+    class ConnectionClosed_ extends UniffiEnum implements ConnectionClosed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ConnectionClosed;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint}>;
+        constructor(
+inner: {peerId: string; connId: bigint }) {
+            super("P2pEvent", "ConnectionClosed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint }): ConnectionClosed_ {
+            return new ConnectionClosed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ConnectionClosed_ {
+            return obj.tag === P2pEvent_Tags.ConnectionClosed;
+        }
+
+    }
+
+    type ConnectionReplaced__interface = {
+        tag: P2pEvent_Tags.ConnectionReplaced;
+        inner:
+Readonly<{peerId: string; oldConnId: bigint; newConnId: bigint}>
+    };
+    /**
+     * A newer connection took the peer's single connection slot from
+     * `old_conn_id`.
+     * The peer stays connected; every stream on `old_conn_id` ended with
+     * it, and a fresh `PeerReady` follows for `new_conn_id`.
+     */
+    class ConnectionReplaced_ extends UniffiEnum implements ConnectionReplaced__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ConnectionReplaced;
+        readonly inner:
+Readonly<{peerId: string; oldConnId: bigint; newConnId: bigint}>;
+        constructor(
+inner: {peerId: string; oldConnId: bigint; newConnId: bigint }) {
+            super("P2pEvent", "ConnectionReplaced");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; oldConnId: bigint; newConnId: bigint }): ConnectionReplaced_ {
+            return new ConnectionReplaced_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ConnectionReplaced_ {
+            return obj.tag === P2pEvent_Tags.ConnectionReplaced;
+        }
+
+    }
+
+    type PeerReady__interface = {
+        tag: P2pEvent_Tags.PeerReady;
+        inner:
+Readonly<{peerId: string; connId: bigint; protocols: Array<string>}>
+    };
+    /**
+     * A peer's connection completed Identify and is ready for application
+     * protocols. Fires once per connection; one whose `conn_id` is no longer
+     * the peer's current connection is stale.
+     */
+    class PeerReady_ extends UniffiEnum implements PeerReady__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerReady;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint; protocols: Array<string>}>;
+        constructor(
+inner: {peerId: string; connId: bigint; protocols: Array<string> }) {
+            super("P2pEvent", "PeerReady");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint; protocols: Array<string> }): PeerReady_ {
+            return new PeerReady_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerReady_ {
+            return obj.tag === P2pEvent_Tags.PeerReady;
+        }
+
+    }
+
+    type IdentifyReceived__interface = {
+        tag: P2pEvent_Tags.IdentifyReceived;
+        inner:
+Readonly<{peerId: string; info: IdentifyInfo}>
+    };
+    /**
+     * A peer supplied a new Identify snapshot.
+     */
+    class IdentifyReceived_ extends UniffiEnum implements IdentifyReceived__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.IdentifyReceived;
+        readonly inner:
+Readonly<{peerId: string; info: IdentifyInfo}>;
+        constructor(
+inner: {peerId: string; info: IdentifyInfo }) {
+            super("P2pEvent", "IdentifyReceived");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; info: IdentifyInfo }): IdentifyReceived_ {
+            return new IdentifyReceived_(inner);
+        }
+
+        static instanceOf(obj: any): obj is IdentifyReceived_ {
+            return obj.tag === P2pEvent_Tags.IdentifyReceived;
+        }
+
+    }
+
+    type PingRttMeasured__interface = {
+        tag: P2pEvent_Tags.PingRttMeasured;
+        inner:
+Readonly<{peerId: string; rttMs: bigint}>
+    };
+    /**
+     * A ping round-trip measurement completed.
+     */
+    class PingRttMeasured_ extends UniffiEnum implements PingRttMeasured__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PingRttMeasured;
+        readonly inner:
+Readonly<{peerId: string; rttMs: bigint}>;
+        constructor(
+inner: {peerId: string; rttMs: bigint }) {
+            super("P2pEvent", "PingRttMeasured");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; rttMs: bigint }): PingRttMeasured_ {
+            return new PingRttMeasured_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PingRttMeasured_ {
+            return obj.tag === P2pEvent_Tags.PingRttMeasured;
+        }
+
+    }
+
+    type PingTimeout__interface = {
+        tag: P2pEvent_Tags.PingTimeout;
+        inner:
+Readonly<{peerId: string}>
+    };
+    /**
+     * A ping timed out.
+     */
+    class PingTimeout_ extends UniffiEnum implements PingTimeout__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PingTimeout;
+        readonly inner:
+Readonly<{peerId: string}>;
+        constructor(
+inner: {peerId: string }) {
+            super("P2pEvent", "PingTimeout");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string }): PingTimeout_ {
+            return new PingTimeout_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PingTimeout_ {
+            return obj.tag === P2pEvent_Tags.PingTimeout;
+        }
+
+    }
+
+    type StreamReady__interface = {
+        tag: P2pEvent_Tags.StreamReady;
+        inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint; protocolId: string; initiatedLocally: boolean}>
+    };
+    /**
+     * A custom application stream completed protocol negotiation.
+     */
+    class StreamReady_ extends UniffiEnum implements StreamReady__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.StreamReady;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint; protocolId: string; initiatedLocally: boolean}>;
+        constructor(
+inner: {peerId: string; connId: bigint; streamId: bigint; protocolId: string; initiatedLocally: boolean }) {
+            super("P2pEvent", "StreamReady");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint; streamId: bigint; protocolId: string; initiatedLocally: boolean }): StreamReady_ {
+            return new StreamReady_(inner);
+        }
+
+        static instanceOf(obj: any): obj is StreamReady_ {
+            return obj.tag === P2pEvent_Tags.StreamReady;
+        }
+
+    }
+
+    type StreamData__interface = {
+        tag: P2pEvent_Tags.StreamData;
+        inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint; data: ArrayBuffer}>
+    };
+    /**
+     * Bytes arrived on a custom application stream.
+     */
+    class StreamData_ extends UniffiEnum implements StreamData__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.StreamData;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint; data: ArrayBuffer}>;
+        constructor(
+inner: {peerId: string; connId: bigint; streamId: bigint; data: ArrayBuffer }) {
+            super("P2pEvent", "StreamData");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint; streamId: bigint; data: ArrayBuffer }): StreamData_ {
+            return new StreamData_(inner);
+        }
+
+        static instanceOf(obj: any): obj is StreamData_ {
+            return obj.tag === P2pEvent_Tags.StreamData;
+        }
+
+    }
+
+    type StreamRemoteWriteClosed__interface = {
+        tag: P2pEvent_Tags.StreamRemoteWriteClosed;
+        inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint}>
+    };
+    /**
+     * The remote peer half-closed its stream write side.
+     */
+    class StreamRemoteWriteClosed_ extends UniffiEnum implements StreamRemoteWriteClosed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.StreamRemoteWriteClosed;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint}>;
+        constructor(
+inner: {peerId: string; connId: bigint; streamId: bigint }) {
+            super("P2pEvent", "StreamRemoteWriteClosed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint; streamId: bigint }): StreamRemoteWriteClosed_ {
+            return new StreamRemoteWriteClosed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is StreamRemoteWriteClosed_ {
+            return obj.tag === P2pEvent_Tags.StreamRemoteWriteClosed;
+        }
+
+    }
+
+    type StreamClosed__interface = {
+        tag: P2pEvent_Tags.StreamClosed;
+        inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint}>
+    };
+    /**
+     * A custom application stream fully closed.
+     */
+    class StreamClosed_ extends UniffiEnum implements StreamClosed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.StreamClosed;
+        readonly inner:
+Readonly<{peerId: string; connId: bigint; streamId: bigint}>;
+        constructor(
+inner: {peerId: string; connId: bigint; streamId: bigint }) {
+            super("P2pEvent", "StreamClosed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; connId: bigint; streamId: bigint }): StreamClosed_ {
+            return new StreamClosed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is StreamClosed_ {
+            return obj.tag === P2pEvent_Tags.StreamClosed;
+        }
+
+    }
+
+    type EndpointError__interface = {
+        tag: P2pEvent_Tags.EndpointError;
+        inner:
+Readonly<{kind: EndpointErrorKind; peerId?: string; connId?: bigint; streamId?: bigint; detail: string}>
+    };
+    /**
+     * A non-fatal endpoint error occurred.
+     */
+    class EndpointError_ extends UniffiEnum implements EndpointError__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.EndpointError;
+        readonly inner:
+Readonly<{kind: EndpointErrorKind; peerId?: string; connId?: bigint; streamId?: bigint; detail: string}>;
+        constructor(
+inner: {kind: EndpointErrorKind; peerId?: string; connId?: bigint; streamId?: bigint; detail: string }) {
+            super("P2pEvent", "EndpointError");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {kind: EndpointErrorKind; peerId?: string; connId?: bigint; streamId?: bigint; detail: string }): EndpointError_ {
+            return new EndpointError_(inner);
+        }
+
+        static instanceOf(obj: any): obj is EndpointError_ {
+            return obj.tag === P2pEvent_Tags.EndpointError;
+        }
+
+    }
+
+    type ReachabilityChanged__interface = {
+        tag: P2pEvent_Tags.ReachabilityChanged;
+        inner:
+Readonly<{previous: Reachability; current: Reachability; confirmedAddrs: Array<string>}>
+    };
+    /**
+     * The local reachability verdict changed.
+     */
+    class ReachabilityChanged_ extends UniffiEnum implements ReachabilityChanged__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ReachabilityChanged;
+        readonly inner:
+Readonly<{previous: Reachability; current: Reachability; confirmedAddrs: Array<string>}>;
+        constructor(
+inner: {previous: Reachability; current: Reachability; confirmedAddrs: Array<string> }) {
+            super("P2pEvent", "ReachabilityChanged");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {previous: Reachability; current: Reachability; confirmedAddrs: Array<string> }): ReachabilityChanged_ {
+            return new ReachabilityChanged_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ReachabilityChanged_ {
+            return obj.tag === P2pEvent_Tags.ReachabilityChanged;
+        }
+
+    }
+
+    type PublicAddressesChanged__interface = {
+        tag: P2pEvent_Tags.PublicAddressesChanged;
+        inner:
+Readonly<{addrs: Array<string>}>
+    };
+    /**
+     * AutoNAT confirmed a changed public address set.
+     */
+    class PublicAddressesChanged_ extends UniffiEnum implements PublicAddressesChanged__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PublicAddressesChanged;
+        readonly inner:
+Readonly<{addrs: Array<string>}>;
+        constructor(
+inner: {addrs: Array<string> }) {
+            super("P2pEvent", "PublicAddressesChanged");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {addrs: Array<string> }): PublicAddressesChanged_ {
+            return new PublicAddressesChanged_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PublicAddressesChanged_ {
+            return obj.tag === P2pEvent_Tags.PublicAddressesChanged;
+        }
+
+    }
+
+    type RelayReserved__interface = {
+        tag: P2pEvent_Tags.RelayReserved;
+        inner:
+Readonly<{relayPeerId: string; expiresUnixSecs?: bigint}>
+    };
+    /**
+     * A relay reservation was acquired or renewed.
+     */
+    class RelayReserved_ extends UniffiEnum implements RelayReserved__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.RelayReserved;
+        readonly inner:
+Readonly<{relayPeerId: string; expiresUnixSecs?: bigint}>;
+        constructor(
+inner: {relayPeerId: string; expiresUnixSecs?: bigint }) {
+            super("P2pEvent", "RelayReserved");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {relayPeerId: string; expiresUnixSecs?: bigint }): RelayReserved_ {
+            return new RelayReserved_(inner);
+        }
+
+        static instanceOf(obj: any): obj is RelayReserved_ {
+            return obj.tag === P2pEvent_Tags.RelayReserved;
+        }
+
+    }
+
+    type RelayReservationLost__interface = {
+        tag: P2pEvent_Tags.RelayReservationLost;
+        inner:
+Readonly<{relayPeerId: string}>
+    };
+    /**
+     * A relay reservation was lost.
+     */
+    class RelayReservationLost_ extends UniffiEnum implements RelayReservationLost__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.RelayReservationLost;
+        readonly inner:
+Readonly<{relayPeerId: string}>;
+        constructor(
+inner: {relayPeerId: string }) {
+            super("P2pEvent", "RelayReservationLost");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {relayPeerId: string }): RelayReservationLost_ {
+            return new RelayReservationLost_(inner);
+        }
+
+        static instanceOf(obj: any): obj is RelayReservationLost_ {
+            return obj.tag === P2pEvent_Tags.RelayReservationLost;
+        }
+
+    }
+
+    type PathEstablished__interface = {
+        tag: P2pEvent_Tags.PathEstablished;
+        inner:
+Readonly<{connectId: bigint; peerId: string; connId: bigint; path: PathKind}>
+    };
+    /**
+     * The first usable path for an attempt became available.
+     */
+    class PathEstablished_ extends UniffiEnum implements PathEstablished__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PathEstablished;
+        readonly inner:
+Readonly<{connectId: bigint; peerId: string; connId: bigint; path: PathKind}>;
+        constructor(
+inner: {connectId: bigint; peerId: string; connId: bigint; path: PathKind }) {
+            super("P2pEvent", "PathEstablished");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {connectId: bigint; peerId: string; connId: bigint; path: PathKind }): PathEstablished_ {
+            return new PathEstablished_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PathEstablished_ {
+            return obj.tag === P2pEvent_Tags.PathEstablished;
+        }
+
+    }
+
+    type InboundPathEstablished__interface = {
+        tag: P2pEvent_Tags.InboundPathEstablished;
+        inner:
+Readonly<{peerId: string; path: PathKind}>
+    };
+    /**
+     * An inbound relay circuit became a usable path.
+     */
+    class InboundPathEstablished_ extends UniffiEnum implements InboundPathEstablished__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.InboundPathEstablished;
+        readonly inner:
+Readonly<{peerId: string; path: PathKind}>;
+        constructor(
+inner: {peerId: string; path: PathKind }) {
+            super("P2pEvent", "InboundPathEstablished");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; path: PathKind }): InboundPathEstablished_ {
+            return new InboundPathEstablished_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InboundPathEstablished_ {
+            return obj.tag === P2pEvent_Tags.InboundPathEstablished;
+        }
+
+    }
+
+    type PathUpgraded__interface = {
+        tag: P2pEvent_Tags.PathUpgraded;
+        inner:
+Readonly<{connectId: bigint; peerId: string; from: PathKind; to: PathKind}>
+    };
+    /**
+     * A better path replaced an earlier path.
+     */
+    class PathUpgraded_ extends UniffiEnum implements PathUpgraded__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PathUpgraded;
+        readonly inner:
+Readonly<{connectId: bigint; peerId: string; from: PathKind; to: PathKind}>;
+        constructor(
+inner: {connectId: bigint; peerId: string; from: PathKind; to: PathKind }) {
+            super("P2pEvent", "PathUpgraded");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {connectId: bigint; peerId: string; from: PathKind; to: PathKind }): PathUpgraded_ {
+            return new PathUpgraded_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PathUpgraded_ {
+            return obj.tag === P2pEvent_Tags.PathUpgraded;
+        }
+
+    }
+
+    type HolePunchFailed__interface = {
+        tag: P2pEvent_Tags.HolePunchFailed;
+        inner:
+Readonly<{connectId: bigint; attempt: number; reason: string}>
+    };
+    /**
+     * One hole-punch window failed.
+     */
+    class HolePunchFailed_ extends UniffiEnum implements HolePunchFailed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.HolePunchFailed;
+        readonly inner:
+Readonly<{connectId: bigint; attempt: number; reason: string}>;
+        constructor(
+inner: {connectId: bigint; attempt: number; reason: string }) {
+            super("P2pEvent", "HolePunchFailed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {connectId: bigint; attempt: number; reason: string }): HolePunchFailed_ {
+            return new HolePunchFailed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is HolePunchFailed_ {
+            return obj.tag === P2pEvent_Tags.HolePunchFailed;
+        }
+
+    }
+
+    type ConnectFailed__interface = {
+        tag: P2pEvent_Tags.ConnectFailed;
+        inner:
+Readonly<{connectId: bigint; peerId: string; kind: NatErrorKind; detail: string}>
+    };
+    /**
+     * A connection attempt ended without a usable path.
+     */
+    class ConnectFailed_ extends UniffiEnum implements ConnectFailed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ConnectFailed;
+        readonly inner:
+Readonly<{connectId: bigint; peerId: string; kind: NatErrorKind; detail: string}>;
+        constructor(
+inner: {connectId: bigint; peerId: string; kind: NatErrorKind; detail: string }) {
+            super("P2pEvent", "ConnectFailed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {connectId: bigint; peerId: string; kind: NatErrorKind; detail: string }): ConnectFailed_ {
+            return new ConnectFailed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ConnectFailed_ {
+            return obj.tag === P2pEvent_Tags.ConnectFailed;
+        }
+
+    }
+
+    type ConnectCancelled__interface = {
+        tag: P2pEvent_Tags.ConnectCancelled;
+        inner:
+Readonly<{connectId: bigint; peerId: string}>
+    };
+    /**
+     * A Connection attempt was cancelled by `cancel_connect` before it
+     * settled. Terminal for that Connect ID.
+     */
+    class ConnectCancelled_ extends UniffiEnum implements ConnectCancelled__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ConnectCancelled;
+        readonly inner:
+Readonly<{connectId: bigint; peerId: string}>;
+        constructor(
+inner: {connectId: bigint; peerId: string }) {
+            super("P2pEvent", "ConnectCancelled");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {connectId: bigint; peerId: string }): ConnectCancelled_ {
+            return new ConnectCancelled_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ConnectCancelled_ {
+            return obj.tag === P2pEvent_Tags.ConnectCancelled;
+        }
+
+    }
+
+    type InboundDirectUpgrade__interface = {
+        tag: P2pEvent_Tags.InboundDirectUpgrade;
+        inner:
+Readonly<{peerId: string}>
+    };
+    /**
+     * An inbound circuit upgraded to a direct connection.
+     */
+    class InboundDirectUpgrade_ extends UniffiEnum implements InboundDirectUpgrade__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.InboundDirectUpgrade;
+        readonly inner:
+Readonly<{peerId: string}>;
+        constructor(
+inner: {peerId: string }) {
+            super("P2pEvent", "InboundDirectUpgrade");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string }): InboundDirectUpgrade_ {
+            return new InboundDirectUpgrade_(inner);
+        }
+
+        static instanceOf(obj: any): obj is InboundDirectUpgrade_ {
+            return obj.tag === P2pEvent_Tags.InboundDirectUpgrade;
+        }
+
+    }
+
+    type Message__interface = {
+        tag: P2pEvent_Tags.Message;
+        inner:
+Readonly<{fromPeerId: string; topics: Array<string>; data: ArrayBuffer; seqno: ArrayBuffer; signed: boolean}>
+    };
+    /**
+     * An accepted pubsub message arrived.
+     *
+     * When unsigned messages are enabled, `signed` can be `false`; hosts
+     * must treat both `from_peer_id` and `data` as unauthenticated unless
+     * `signed` is `true`.
+     */
+    class Message_ extends UniffiEnum implements Message__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.Message;
+        readonly inner:
+Readonly<{fromPeerId: string; topics: Array<string>; data: ArrayBuffer; seqno: ArrayBuffer; signed: boolean}>;
+        constructor(
+inner: {fromPeerId: string; topics: Array<string>; data: ArrayBuffer; seqno: ArrayBuffer; signed: boolean }) {
+            super("P2pEvent", "Message");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {fromPeerId: string; topics: Array<string>; data: ArrayBuffer; seqno: ArrayBuffer; signed: boolean }): Message_ {
+            return new Message_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Message_ {
+            return obj.tag === P2pEvent_Tags.Message;
+        }
+
+    }
+
+    type PeerSubscribed__interface = {
+        tag: P2pEvent_Tags.PeerSubscribed;
+        inner:
+Readonly<{peerId: string; topic: string}>
+    };
+    /**
+     * A peer announced a subscription.
+     */
+    class PeerSubscribed_ extends UniffiEnum implements PeerSubscribed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerSubscribed;
+        readonly inner:
+Readonly<{peerId: string; topic: string}>;
+        constructor(
+inner: {peerId: string; topic: string }) {
+            super("P2pEvent", "PeerSubscribed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; topic: string }): PeerSubscribed_ {
+            return new PeerSubscribed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerSubscribed_ {
+            return obj.tag === P2pEvent_Tags.PeerSubscribed;
+        }
+
+    }
+
+    type PeerUnsubscribed__interface = {
+        tag: P2pEvent_Tags.PeerUnsubscribed;
+        inner:
+Readonly<{peerId: string; topic: string}>
+    };
+    /**
+     * A peer's subscription ended: withdrawn, or its connection closed or was replaced.
+     */
+    class PeerUnsubscribed_ extends UniffiEnum implements PeerUnsubscribed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerUnsubscribed;
+        readonly inner:
+Readonly<{peerId: string; topic: string}>;
+        constructor(
+inner: {peerId: string; topic: string }) {
+            super("P2pEvent", "PeerUnsubscribed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; topic: string }): PeerUnsubscribed_ {
+            return new PeerUnsubscribed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerUnsubscribed_ {
+            return obj.tag === P2pEvent_Tags.PeerUnsubscribed;
+        }
+
+    }
+
+    type GossipsubOutboundFailure__interface = {
+        tag: P2pEvent_Tags.GossipsubOutboundFailure;
+        inner:
+Readonly<{peerId: string; reason: string}>
+    };
+    /**
+     * Gossipsub outbound work was discarded.
+     */
+    class GossipsubOutboundFailure_ extends UniffiEnum implements GossipsubOutboundFailure__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.GossipsubOutboundFailure;
+        readonly inner:
+Readonly<{peerId: string; reason: string}>;
+        constructor(
+inner: {peerId: string; reason: string }) {
+            super("P2pEvent", "GossipsubOutboundFailure");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; reason: string }): GossipsubOutboundFailure_ {
+            return new GossipsubOutboundFailure_(inner);
+        }
+
+        static instanceOf(obj: any): obj is GossipsubOutboundFailure_ {
+            return obj.tag === P2pEvent_Tags.GossipsubOutboundFailure;
+        }
+
+    }
+
+    type GossipsubProtocolViolation__interface = {
+        tag: P2pEvent_Tags.GossipsubProtocolViolation;
+        inner:
+Readonly<{peerId: string; reason: string}>
+    };
+    /**
+     * A peer violated the gossipsub protocol.
+     */
+    class GossipsubProtocolViolation_ extends UniffiEnum implements GossipsubProtocolViolation__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.GossipsubProtocolViolation;
+        readonly inner:
+Readonly<{peerId: string; reason: string}>;
+        constructor(
+inner: {peerId: string; reason: string }) {
+            super("P2pEvent", "GossipsubProtocolViolation");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; reason: string }): GossipsubProtocolViolation_ {
+            return new GossipsubProtocolViolation_(inner);
+        }
+
+        static instanceOf(obj: any): obj is GossipsubProtocolViolation_ {
+            return obj.tag === P2pEvent_Tags.GossipsubProtocolViolation;
+        }
+
+    }
+
+    type PeerDiscovered__interface = {
+        tag: P2pEvent_Tags.PeerDiscovered;
+        inner:
+Readonly<{peerId: string; addrs: Array<string>; source: DiscoverySource}>
+    };
+    /**
+     * Discovery introduced a peer.
+     */
+    class PeerDiscovered_ extends UniffiEnum implements PeerDiscovered__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerDiscovered;
+        readonly inner:
+Readonly<{peerId: string; addrs: Array<string>; source: DiscoverySource}>;
+        constructor(
+inner: {peerId: string; addrs: Array<string>; source: DiscoverySource }) {
+            super("P2pEvent", "PeerDiscovered");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; addrs: Array<string>; source: DiscoverySource }): PeerDiscovered_ {
+            return new PeerDiscovered_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerDiscovered_ {
+            return obj.tag === P2pEvent_Tags.PeerDiscovered;
+        }
+
+    }
+
+    type PeerUpdated__interface = {
+        tag: P2pEvent_Tags.PeerUpdated;
+        inner:
+Readonly<{peerId: string; addrs: Array<string>; source: DiscoverySource}>
+    };
+    /**
+     * Discovery updated a peer.
+     */
+    class PeerUpdated_ extends UniffiEnum implements PeerUpdated__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerUpdated;
+        readonly inner:
+Readonly<{peerId: string; addrs: Array<string>; source: DiscoverySource}>;
+        constructor(
+inner: {peerId: string; addrs: Array<string>; source: DiscoverySource }) {
+            super("P2pEvent", "PeerUpdated");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; addrs: Array<string>; source: DiscoverySource }): PeerUpdated_ {
+            return new PeerUpdated_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerUpdated_ {
+            return obj.tag === P2pEvent_Tags.PeerUpdated;
+        }
+
+    }
+
+    type PeerExpired__interface = {
+        tag: P2pEvent_Tags.PeerExpired;
+        inner:
+Readonly<{peerId: string}>
+    };
+    /**
+     * A discovered peer expired or was evicted.
+     */
+    class PeerExpired_ extends UniffiEnum implements PeerExpired__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.PeerExpired;
+        readonly inner:
+Readonly<{peerId: string}>;
+        constructor(
+inner: {peerId: string }) {
+            super("P2pEvent", "PeerExpired");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string }): PeerExpired_ {
+            return new PeerExpired_(inner);
+        }
+
+        static instanceOf(obj: any): obj is PeerExpired_ {
+            return obj.tag === P2pEvent_Tags.PeerExpired;
+        }
+
+    }
+
+    type DiscoveryDialFailed__interface = {
+        tag: P2pEvent_Tags.DiscoveryDialFailed;
+        inner:
+Readonly<{peerId: string; reason: string}>
+    };
+    /**
+     * An automatic discovery dial failed.
+     */
+    class DiscoveryDialFailed_ extends UniffiEnum implements DiscoveryDialFailed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.DiscoveryDialFailed;
+        readonly inner:
+Readonly<{peerId: string; reason: string}>;
+        constructor(
+inner: {peerId: string; reason: string }) {
+            super("P2pEvent", "DiscoveryDialFailed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string; reason: string }): DiscoveryDialFailed_ {
+            return new DiscoveryDialFailed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is DiscoveryDialFailed_ {
+            return obj.tag === P2pEvent_Tags.DiscoveryDialFailed;
+        }
+
+    }
+
+    type DiscoveryProtocolViolation__interface = {
+        tag: P2pEvent_Tags.DiscoveryProtocolViolation;
+        inner:
+Readonly<{peerId?: string; source: DiscoverySource; reason: string; suppressed: number}>
+    };
+    /**
+     * A discovery source supplied an invalid claim.
+     */
+    class DiscoveryProtocolViolation_ extends UniffiEnum implements DiscoveryProtocolViolation__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.DiscoveryProtocolViolation;
+        readonly inner:
+Readonly<{peerId?: string; source: DiscoverySource; reason: string; suppressed: number}>;
+        constructor(
+inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: number }) {
+            super("P2pEvent", "DiscoveryProtocolViolation");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: number }): DiscoveryProtocolViolation_ {
+            return new DiscoveryProtocolViolation_(inner);
+        }
+
+        static instanceOf(obj: any): obj is DiscoveryProtocolViolation_ {
+            return obj.tag === P2pEvent_Tags.DiscoveryProtocolViolation;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is P2pEvent {
+        return obj[uniffiTypeNameSymbol] === "P2pEvent";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  EventsDropped: EventsDropped_,
+  DriverFailed: DriverFailed_,
+  ConnectionEstablished: ConnectionEstablished_,
+  ConnectionClosed: ConnectionClosed_,
+  ConnectionReplaced: ConnectionReplaced_,
+  PeerReady: PeerReady_,
+  IdentifyReceived: IdentifyReceived_,
+  PingRttMeasured: PingRttMeasured_,
+  PingTimeout: PingTimeout_,
+  StreamReady: StreamReady_,
+  StreamData: StreamData_,
+  StreamRemoteWriteClosed: StreamRemoteWriteClosed_,
+  StreamClosed: StreamClosed_,
+  EndpointError: EndpointError_,
+  ReachabilityChanged: ReachabilityChanged_,
+  PublicAddressesChanged: PublicAddressesChanged_,
+  RelayReserved: RelayReserved_,
+  RelayReservationLost: RelayReservationLost_,
+  PathEstablished: PathEstablished_,
+  InboundPathEstablished: InboundPathEstablished_,
+  PathUpgraded: PathUpgraded_,
+  HolePunchFailed: HolePunchFailed_,
+  ConnectFailed: ConnectFailed_,
+  ConnectCancelled: ConnectCancelled_,
+  InboundDirectUpgrade: InboundDirectUpgrade_,
+  Message: Message_,
+  PeerSubscribed: PeerSubscribed_,
+  PeerUnsubscribed: PeerUnsubscribed_,
+  GossipsubOutboundFailure: GossipsubOutboundFailure_,
+  GossipsubProtocolViolation: GossipsubProtocolViolation_,
+  PeerDiscovered: PeerDiscovered_,
+  PeerUpdated: PeerUpdated_,
+  PeerExpired: PeerExpired_,
+  DiscoveryDialFailed: DiscoveryDialFailed_,
+  DiscoveryProtocolViolation: DiscoveryProtocolViolation_
+    });
+
+})();
+/**
+ * Event delivered by the native endpoint driver.
+ */
+export type P2pEvent = InstanceType<
+    typeof P2pEvent['EventsDropped' | 'DriverFailed' | 'ConnectionEstablished' | 'ConnectionClosed' | 'ConnectionReplaced' | 'PeerReady' | 'IdentifyReceived' | 'PingRttMeasured' | 'PingTimeout' | 'StreamReady' | 'StreamData' | 'StreamRemoteWriteClosed' | 'StreamClosed' | 'EndpointError' | 'ReachabilityChanged' | 'PublicAddressesChanged' | 'RelayReserved' | 'RelayReservationLost' | 'PathEstablished' | 'InboundPathEstablished' | 'PathUpgraded' | 'HolePunchFailed' | 'ConnectFailed' | 'ConnectCancelled' | 'InboundDirectUpgrade' | 'Message' | 'PeerSubscribed' | 'PeerUnsubscribed' | 'GossipsubOutboundFailure' | 'GossipsubProtocolViolation' | 'PeerDiscovered' | 'PeerUpdated' | 'PeerExpired' | 'DiscoveryDialFailed' | 'DiscoveryProtocolViolation']
+>;
+
+// FfiConverter for enum P2pEvent
+const FfiConverterTypeP2pEvent = (() => {
+    type TypeName = P2pEvent;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new P2pEvent.EventsDropped({dropped: FfiConverterUInt64.readFromCursor(c), totalDropped: FfiConverterUInt64.readFromCursor(c), terminalConnectIds: FfiConverterSequenceUInt64.readFromCursor(c) });
+                case 2: return new P2pEvent.DriverFailed({kind: FfiConverterTypeDriverFailureKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 3: return new P2pEvent.ConnectionEstablished({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
+                case 4: return new P2pEvent.ConnectionClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
+                case 5: return new P2pEvent.ConnectionReplaced({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
+                case 6: return new P2pEvent.PeerReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), protocols: FfiConverterSequenceString.readFromCursor(c) });
+                case 7: return new P2pEvent.IdentifyReceived({peerId: FfiConverterString.readFromCursor(c), info: FfiConverterTypeIdentifyInfo.readFromCursor(c) });
+                case 8: return new P2pEvent.PingRttMeasured({peerId: FfiConverterString.readFromCursor(c), rttMs: FfiConverterUInt64.readFromCursor(c) });
+                case 9: return new P2pEvent.PingTimeout({peerId: FfiConverterString.readFromCursor(c) });
+                case 10: return new P2pEvent.StreamReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), protocolId: FfiConverterString.readFromCursor(c), initiatedLocally: FfiConverterBool.readFromCursor(c) });
+                case 11: return new P2pEvent.StreamData({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c) });
+                case 12: return new P2pEvent.StreamRemoteWriteClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
+                case 13: return new P2pEvent.StreamClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
+                case 14: return new P2pEvent.EndpointError({kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c), peerId: FfiConverterOptionalString.readFromCursor(c), connId: FfiConverterOptionalUInt64.readFromCursor(c), streamId: FfiConverterOptionalUInt64.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 15: return new P2pEvent.ReachabilityChanged({previous: FfiConverterTypeReachability.readFromCursor(c), current: FfiConverterTypeReachability.readFromCursor(c), confirmedAddrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 16: return new P2pEvent.PublicAddressesChanged({addrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 17: return new P2pEvent.RelayReserved({relayPeerId: FfiConverterString.readFromCursor(c), expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c) });
+                case 18: return new P2pEvent.RelayReservationLost({relayPeerId: FfiConverterString.readFromCursor(c) });
+                case 19: return new P2pEvent.PathEstablished({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c) });
+                case 20: return new P2pEvent.InboundPathEstablished({peerId: FfiConverterString.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c) });
+                case 21: return new P2pEvent.PathUpgraded({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), from: FfiConverterTypePathKind.readFromCursor(c), to: FfiConverterTypePathKind.readFromCursor(c) });
+                case 22: return new P2pEvent.HolePunchFailed({connectId: FfiConverterUInt64.readFromCursor(c), attempt: FfiConverterUInt32.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 23: return new P2pEvent.ConnectFailed({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), kind: FfiConverterTypeNatErrorKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 24: return new P2pEvent.ConnectCancelled({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c) });
+                case 25: return new P2pEvent.InboundDirectUpgrade({peerId: FfiConverterString.readFromCursor(c) });
+                case 26: return new P2pEvent.Message({fromPeerId: FfiConverterString.readFromCursor(c), topics: FfiConverterSequenceString.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c), seqno: FfiConverterArrayBuffer.readFromCursor(c), signed: FfiConverterBool.readFromCursor(c) });
+                case 27: return new P2pEvent.PeerSubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 28: return new P2pEvent.PeerUnsubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 29: return new P2pEvent.GossipsubOutboundFailure({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 30: return new P2pEvent.GossipsubProtocolViolation({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 31: return new P2pEvent.PeerDiscovered({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 32: return new P2pEvent.PeerUpdated({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 33: return new P2pEvent.PeerExpired({peerId: FfiConverterString.readFromCursor(c) });
+                case 34: return new P2pEvent.DiscoveryDialFailed({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 35: return new P2pEvent.DiscoveryProtocolViolation({peerId: FfiConverterOptionalString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c), reason: FfiConverterString.readFromCursor(c), suppressed: FfiConverterUInt32.readFromCursor(c) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case P2pEvent_Tags.EventsDropped: {
+                    c.writeI32(1);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.dropped, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.totalDropped, c);
+                    FfiConverterSequenceUInt64.writeIntoCursor(inner.terminalConnectIds, c);
+                    return;
+                }
+                case P2pEvent_Tags.DriverFailed: {
+                    c.writeI32(2);
+                    const inner = value.inner;
+                    FfiConverterTypeDriverFailureKind.writeIntoCursor(inner.kind, c);
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case P2pEvent_Tags.ConnectionEstablished: {
+                    c.writeI32(3);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    return;
+                }
+                case P2pEvent_Tags.ConnectionClosed: {
+                    c.writeI32(4);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    return;
+                }
+                case P2pEvent_Tags.ConnectionReplaced: {
+                    c.writeI32(5);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.newConnId, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerReady: {
+                    c.writeI32(6);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterSequenceString.writeIntoCursor(inner.protocols, c);
+                    return;
+                }
+                case P2pEvent_Tags.IdentifyReceived: {
+                    c.writeI32(7);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterTypeIdentifyInfo.writeIntoCursor(inner.info, c);
+                    return;
+                }
+                case P2pEvent_Tags.PingRttMeasured: {
+                    c.writeI32(8);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.rttMs, c);
+                    return;
+                }
+                case P2pEvent_Tags.PingTimeout: {
+                    c.writeI32(9);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    return;
+                }
+                case P2pEvent_Tags.StreamReady: {
+                    c.writeI32(10);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+                    FfiConverterString.writeIntoCursor(inner.protocolId, c);
+                    FfiConverterBool.writeIntoCursor(inner.initiatedLocally, c);
+                    return;
+                }
+                case P2pEvent_Tags.StreamData: {
+                    c.writeI32(11);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+                    FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
+                    return;
+                }
+                case P2pEvent_Tags.StreamRemoteWriteClosed: {
+                    c.writeI32(12);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+                    return;
+                }
+                case P2pEvent_Tags.StreamClosed: {
+                    c.writeI32(13);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+                    return;
+                }
+                case P2pEvent_Tags.EndpointError: {
+                    c.writeI32(14);
+                    const inner = value.inner;
+                    FfiConverterTypeEndpointErrorKind.writeIntoCursor(inner.kind, c);
+                    FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterOptionalUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterOptionalUInt64.writeIntoCursor(inner.streamId, c);
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case P2pEvent_Tags.ReachabilityChanged: {
+                    c.writeI32(15);
+                    const inner = value.inner;
+                    FfiConverterTypeReachability.writeIntoCursor(inner.previous, c);
+                    FfiConverterTypeReachability.writeIntoCursor(inner.current, c);
+                    FfiConverterSequenceString.writeIntoCursor(inner.confirmedAddrs, c);
+                    return;
+                }
+                case P2pEvent_Tags.PublicAddressesChanged: {
+                    c.writeI32(16);
+                    const inner = value.inner;
+                    FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+                    return;
+                }
+                case P2pEvent_Tags.RelayReserved: {
+                    c.writeI32(17);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+                    FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
+                    return;
+                }
+                case P2pEvent_Tags.RelayReservationLost: {
+                    c.writeI32(18);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+                    return;
+                }
+                case P2pEvent_Tags.PathEstablished: {
+                    c.writeI32(19);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+                    FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
+                    return;
+                }
+                case P2pEvent_Tags.InboundPathEstablished: {
+                    c.writeI32(20);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
+                    return;
+                }
+                case P2pEvent_Tags.PathUpgraded: {
+                    c.writeI32(21);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterTypePathKind.writeIntoCursor(inner.from, c);
+                    FfiConverterTypePathKind.writeIntoCursor(inner.to, c);
+                    return;
+                }
+                case P2pEvent_Tags.HolePunchFailed: {
+                    c.writeI32(22);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+                    FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
+                    FfiConverterString.writeIntoCursor(inner.reason, c);
+                    return;
+                }
+                case P2pEvent_Tags.ConnectFailed: {
+                    c.writeI32(23);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterTypeNatErrorKind.writeIntoCursor(inner.kind, c);
+                    FfiConverterString.writeIntoCursor(inner.detail, c);
+                    return;
+                }
+                case P2pEvent_Tags.ConnectCancelled: {
+                    c.writeI32(24);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    return;
+                }
+                case P2pEvent_Tags.InboundDirectUpgrade: {
+                    c.writeI32(25);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    return;
+                }
+                case P2pEvent_Tags.Message: {
+                    c.writeI32(26);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
+                    FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
+                    FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
+                    FfiConverterArrayBuffer.writeIntoCursor(inner.seqno, c);
+                    FfiConverterBool.writeIntoCursor(inner.signed, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerSubscribed: {
+                    c.writeI32(27);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterString.writeIntoCursor(inner.topic, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerUnsubscribed: {
+                    c.writeI32(28);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterString.writeIntoCursor(inner.topic, c);
+                    return;
+                }
+                case P2pEvent_Tags.GossipsubOutboundFailure: {
+                    c.writeI32(29);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterString.writeIntoCursor(inner.reason, c);
+                    return;
+                }
+                case P2pEvent_Tags.GossipsubProtocolViolation: {
+                    c.writeI32(30);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterString.writeIntoCursor(inner.reason, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerDiscovered: {
+                    c.writeI32(31);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+                    FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerUpdated: {
+                    c.writeI32(32);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+                    FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+                    return;
+                }
+                case P2pEvent_Tags.PeerExpired: {
+                    c.writeI32(33);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    return;
+                }
+                case P2pEvent_Tags.DiscoveryDialFailed: {
+                    c.writeI32(34);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterString.writeIntoCursor(inner.reason, c);
+                    return;
+                }
+                case P2pEvent_Tags.DiscoveryProtocolViolation: {
+                    c.writeI32(35);
+                    const inner = value.inner;
+                    FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+                    FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+                    FfiConverterString.writeIntoCursor(inner.reason, c);
+                    FfiConverterUInt32.writeIntoCursor(inner.suppressed, c);
+                    return;
+                }
+                default:
+                    // Throwing from here means that P2pEvent_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case P2pEvent_Tags.EventsDropped: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.dropped);
+                    size += FfiConverterUInt64.allocationSize(inner.totalDropped);
+                    size += FfiConverterSequenceUInt64.allocationSize(inner.terminalConnectIds);
+                    return size;
+                }
+                case P2pEvent_Tags.DriverFailed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterTypeDriverFailureKind.allocationSize(inner.kind);
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case P2pEvent_Tags.ConnectionEstablished: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    return size;
+                }
+                case P2pEvent_Tags.ConnectionClosed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    return size;
+                }
+                case P2pEvent_Tags.ConnectionReplaced: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.oldConnId);
+                    size += FfiConverterUInt64.allocationSize(inner.newConnId);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerReady: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterSequenceString.allocationSize(inner.protocols);
+                    return size;
+                }
+                case P2pEvent_Tags.IdentifyReceived: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterTypeIdentifyInfo.allocationSize(inner.info);
+                    return size;
+                }
+                case P2pEvent_Tags.PingRttMeasured: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.rttMs);
+                    return size;
+                }
+                case P2pEvent_Tags.PingTimeout: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    return size;
+                }
+                case P2pEvent_Tags.StreamReady: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterUInt64.allocationSize(inner.streamId);
+                    size += FfiConverterString.allocationSize(inner.protocolId);
+                    size += FfiConverterBool.allocationSize(inner.initiatedLocally);
+                    return size;
+                }
+                case P2pEvent_Tags.StreamData: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterUInt64.allocationSize(inner.streamId);
+                    size += FfiConverterArrayBuffer.allocationSize(inner.data);
+                    return size;
+                }
+                case P2pEvent_Tags.StreamRemoteWriteClosed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterUInt64.allocationSize(inner.streamId);
+                    return size;
+                }
+                case P2pEvent_Tags.StreamClosed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterUInt64.allocationSize(inner.streamId);
+                    return size;
+                }
+                case P2pEvent_Tags.EndpointError: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterTypeEndpointErrorKind.allocationSize(inner.kind);
+                    size += FfiConverterOptionalString.allocationSize(inner.peerId);
+                    size += FfiConverterOptionalUInt64.allocationSize(inner.connId);
+                    size += FfiConverterOptionalUInt64.allocationSize(inner.streamId);
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case P2pEvent_Tags.ReachabilityChanged: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterTypeReachability.allocationSize(inner.previous);
+                    size += FfiConverterTypeReachability.allocationSize(inner.current);
+                    size += FfiConverterSequenceString.allocationSize(inner.confirmedAddrs);
+                    return size;
+                }
+                case P2pEvent_Tags.PublicAddressesChanged: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterSequenceString.allocationSize(inner.addrs);
+                    return size;
+                }
+                case P2pEvent_Tags.RelayReserved: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.relayPeerId);
+                    size += FfiConverterOptionalUInt64.allocationSize(inner.expiresUnixSecs);
+                    return size;
+                }
+                case P2pEvent_Tags.RelayReservationLost: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.relayPeerId);
+                    return size;
+                }
+                case P2pEvent_Tags.PathEstablished: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.connectId);
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterUInt64.allocationSize(inner.connId);
+                    size += FfiConverterTypePathKind.allocationSize(inner.path);
+                    return size;
+                }
+                case P2pEvent_Tags.InboundPathEstablished: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterTypePathKind.allocationSize(inner.path);
+                    return size;
+                }
+                case P2pEvent_Tags.PathUpgraded: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.connectId);
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterTypePathKind.allocationSize(inner.from);
+                    size += FfiConverterTypePathKind.allocationSize(inner.to);
+                    return size;
+                }
+                case P2pEvent_Tags.HolePunchFailed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.connectId);
+                    size += FfiConverterUInt32.allocationSize(inner.attempt);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case P2pEvent_Tags.ConnectFailed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.connectId);
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterTypeNatErrorKind.allocationSize(inner.kind);
+                    size += FfiConverterString.allocationSize(inner.detail);
+                    return size;
+                }
+                case P2pEvent_Tags.ConnectCancelled: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.connectId);
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    return size;
+                }
+                case P2pEvent_Tags.InboundDirectUpgrade: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    return size;
+                }
+                case P2pEvent_Tags.Message: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.fromPeerId);
+                    size += FfiConverterSequenceString.allocationSize(inner.topics);
+                    size += FfiConverterArrayBuffer.allocationSize(inner.data);
+                    size += FfiConverterArrayBuffer.allocationSize(inner.seqno);
+                    size += FfiConverterBool.allocationSize(inner.signed);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerSubscribed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterString.allocationSize(inner.topic);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerUnsubscribed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterString.allocationSize(inner.topic);
+                    return size;
+                }
+                case P2pEvent_Tags.GossipsubOutboundFailure: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case P2pEvent_Tags.GossipsubProtocolViolation: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerDiscovered: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterSequenceString.allocationSize(inner.addrs);
+                    size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerUpdated: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterSequenceString.allocationSize(inner.addrs);
+                    size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+                    return size;
+                }
+                case P2pEvent_Tags.PeerExpired: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    return size;
+                }
+                case P2pEvent_Tags.DiscoveryDialFailed: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.peerId);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case P2pEvent_Tags.DiscoveryProtocolViolation: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterOptionalString.allocationSize(inner.peerId);
+                    size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    size += FfiConverterUInt32.allocationSize(inner.suppressed);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for Array<string> | undefined
+const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+
+// FfiConverter for DiscoveryOptions | undefined
+const FfiConverterOptionalTypeDiscoveryOptions = new FfiConverterOptional(FfiConverterTypeDiscoveryOptions);
+
+// FfiConverter for MdnsOptions | undefined
+const FfiConverterOptionalTypeMdnsOptions = new FfiConverterOptional(FfiConverterTypeMdnsOptions);
+
+// FfiConverter for ArrayBuffer | undefined
+const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
+
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
+// FfiConverter for Array<bigint>
+const FfiConverterSequenceUInt64 = new FfiConverterArray(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().ubrn_ffi_minip2p_ffi_core_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeConnectTarget,
+    FfiConverterTypeConnectionInfo,
+    FfiConverterTypeDiscoveryOptions,
+    FfiConverterTypeDiscoverySource,
+    FfiConverterTypeDriverFailureKind,
+    FfiConverterTypeEndpointConfig,
+    FfiConverterTypeEndpointErrorKind,
+    FfiConverterTypeFfiError,
+    FfiConverterTypeIdentifyInfo,
+    FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeMdnsOptions,
+    FfiConverterTypeNatErrorKind,
+    FfiConverterTypeOpenStreamResult,
+    FfiConverterTypeP2pEvent,
+    FfiConverterTypePathKind,
+    FfiConverterTypeReachability,
+    FfiConverterTypeRelayReservationInfo,
+  }
+});