@minip2p/react-native 0.7.3 → 0.7.5

package/lib/typescript/src/generated/minip2p_ffi_core.d.ts

@@ -0,0 +1,3522 @@
+import { type UniffiByteArray, Cursor, uniffiTypeNameSymbol } from "@ubjs/core";
+/**
+ * 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 declare const ConnectionInfo: Readonly<{
+    create: (partial: Partial<ConnectionInfo> & Required<Omit<ConnectionInfo, "readyProtocols" | "remoteAddr">>) => ConnectionInfo;
+    new: (partial: Partial<ConnectionInfo> & Required<Omit<ConnectionInfo, "readyProtocols" | "remoteAddr">>) => ConnectionInfo;
+    defaults: () => Partial<ConnectionInfo>;
+}>;
+/**
+ * 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 declare const DiscoveryOptions: Readonly<{
+    create: (partial: Partial<DiscoveryOptions> & Required<Omit<DiscoveryOptions, never>>) => DiscoveryOptions;
+    new: (partial: Partial<DiscoveryOptions> & Required<Omit<DiscoveryOptions, never>>) => DiscoveryOptions;
+    defaults: () => Partial<DiscoveryOptions>;
+}>;
+/**
+ * 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 declare const MdnsOptions: Readonly<{
+    create: (partial: Partial<MdnsOptions> & Required<Omit<MdnsOptions, never>>) => MdnsOptions;
+    new: (partial: Partial<MdnsOptions> & Required<Omit<MdnsOptions, never>>) => MdnsOptions;
+    defaults: () => Partial<MdnsOptions>;
+}>;
+/**
+ * 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 declare const EndpointConfig: Readonly<{
+    create: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "listen" | "mdns">>) => EndpointConfig;
+    new: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "listen" | "mdns">>) => EndpointConfig;
+    defaults: () => Partial<EndpointConfig>;
+}>;
+/**
+ * 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 declare const IdentifyInfo: Readonly<{
+    create: (partial: Partial<IdentifyInfo> & Required<Omit<IdentifyInfo, "agentVersion" | "observedAddr" | "protocolVersion" | "publicKey">>) => IdentifyInfo;
+    new: (partial: Partial<IdentifyInfo> & Required<Omit<IdentifyInfo, "agentVersion" | "observedAddr" | "protocolVersion" | "publicKey">>) => IdentifyInfo;
+    defaults: () => Partial<IdentifyInfo>;
+}>;
+/**
+ * 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 declare const KnownPeerInfo: Readonly<{
+    create: (partial: Partial<KnownPeerInfo> & Required<Omit<KnownPeerInfo, "beaconLastSeenAgeMs" | "mdnsLastSeenAgeMs">>) => KnownPeerInfo;
+    new: (partial: Partial<KnownPeerInfo> & Required<Omit<KnownPeerInfo, "beaconLastSeenAgeMs" | "mdnsLastSeenAgeMs">>) => KnownPeerInfo;
+    defaults: () => Partial<KnownPeerInfo>;
+}>;
+/**
+ * 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 declare const OpenStreamResult: Readonly<{
+    create: (partial: Partial<OpenStreamResult> & Required<Omit<OpenStreamResult, never>>) => OpenStreamResult;
+    new: (partial: Partial<OpenStreamResult> & Required<Omit<OpenStreamResult, never>>) => OpenStreamResult;
+    defaults: () => Partial<OpenStreamResult>;
+}>;
+/**
+ * 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 declare const RelayReservationInfo: Readonly<{
+    create: (partial: Partial<RelayReservationInfo> & Required<Omit<RelayReservationInfo, "expiresUnixSecs">>) => RelayReservationInfo;
+    new: (partial: Partial<RelayReservationInfo> & Required<Omit<RelayReservationInfo, "expiresUnixSecs">>) => RelayReservationInfo;
+    defaults: () => Partial<RelayReservationInfo>;
+}>;
+export declare 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 declare const ConnectTarget: Readonly<{
+    instanceOf: (obj: any) => obj is ConnectTarget;
+    Peer: {
+        new (inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    Addresses: {
+        new (inner: {
+            addresses: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            addresses: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
+}>;
+/**
+ * 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']>;
+/**
+ * Source that contributed a discovery observation.
+ */
+export declare enum DiscoverySource {
+    /**
+     * Public-key-authenticated signed beacon.
+     */
+    SignedBeacon = 0,
+    /**
+     * Unauthenticated local-link mDNS observation.
+     */
+    Mdns = 1
+}
+/**
+ * Category of a fatal background-driver failure.
+ */
+export declare enum DriverFailureKind {
+    /**
+     * The transport driver failed.
+     */
+    Transport = 0,
+    /**
+     * The swarm driver failed.
+     */
+    Swarm = 1,
+    /**
+     * An internal driver invariant failed.
+     */
+    Invariant = 2,
+    /**
+     * The background pump panicked.
+     */
+    Panic = 3
+}
+/**
+ * Category of a non-fatal endpoint runtime error.
+ */
+export declare enum EndpointErrorKind {
+    /**
+     * Underlying transport operation failed.
+     */
+    Transport = 0,
+    /**
+     * Multistream negotiation failed.
+     */
+    Multistream = 1,
+    /**
+     * Identify protocol failed.
+     */
+    Identify = 2,
+    /**
+     * Ping protocol failed.
+     */
+    Ping = 3,
+    /**
+     * Identify stream setup was rejected.
+     */
+    IdentifyStreamRejected = 4,
+    /**
+     * Outbound stream opening failed.
+     */
+    OpenStreamFailed = 5,
+    /**
+     * The remote does not support a requested protocol.
+     */
+    UnsupportedProtocol = 6,
+    /**
+     * The swarm driver contract failed.
+     */
+    Driver = 7
+}
+export declare 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 declare const FfiError: Readonly<{
+    instanceOf: (obj: any) => obj is FfiError;
+    AlreadyStarted: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.AlreadyStarted;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.AlreadyStarted;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.AlreadyStarted;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.AlreadyStarted;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+    };
+    Stopped: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Stopped;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Stopped;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Stopped;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Stopped;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+    };
+    InvalidConfig: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidKey: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidPeerId: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidAddress: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidTopic: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    NotPermitted: {
+        new (inner: {
+            detail: string;
+        }): {
+            name: string;
+            message: string;
+            stack?: string;
+            /**
+             * @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;
+            }>;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            name: string;
+            message: string;
+            stack?: string;
+            /**
+             * @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;
+            }>;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            name: string;
+            message: string;
+            stack?: string;
+            /**
+             * @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;
+            }>;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            name: string;
+            message: string;
+            stack?: string;
+            /**
+             * @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;
+            }>;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            name: string;
+            message: string;
+            stack?: string;
+            /**
+             * @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;
+            }>;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Backpressure: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Backpressure;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Backpressure;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Backpressure;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.Backpressure;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+    };
+    MessageTooLarge: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.MessageTooLarge;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.MessageTooLarge;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.MessageTooLarge;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiError";
+            readonly tag: FfiError_Tags.MessageTooLarge;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+    };
+    Transport: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    InvalidState: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+    Internal: {
+        new (inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            /**
+             * @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;
+            }>;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            detail: string;
+        }>;
+        isError(error: unknown): error is Error;
+    };
+}>;
+/**
+ * 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']>;
+/**
+ * Category of a failed NAT connection attempt.
+ */
+export declare enum NatErrorKind {
+    /**
+     * No usable direct or relayed path exists.
+     */
+    NoPathAvailable = 0,
+    /**
+     * The connection attempt timed out.
+     */
+    Timeout = 1,
+    /**
+     * A transport dial failed.
+     */
+    DialFailed = 2,
+    /**
+     * A traversal protocol exchange failed.
+     */
+    Protocol = 3,
+    /**
+     * A relay refused the circuit.
+     */
+    RelayRefused = 4
+}
+/**
+ * Coarse local reachability state.
+ */
+export declare enum Reachability {
+    /**
+     * Not enough evidence is available.
+     */
+    Unknown = 0,
+    /**
+     * The endpoint is directly reachable.
+     */
+    Public = 1,
+    /**
+     * The endpoint needs traversal or relay assistance.
+     */
+    Private = 2
+}
+export declare enum PathKind_Tags {
+    DirectDialed = "DirectDialed",
+    DirectPunched = "DirectPunched",
+    Relayed = "Relayed"
+}
+/**
+ * Kind of usable connection path.
+ */
+export declare const PathKind: Readonly<{
+    instanceOf: (obj: any) => obj is PathKind;
+    DirectDialed: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectDialed;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectDialed;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectDialed;
+        };
+    };
+    DirectPunched: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectPunched;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectPunched;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PathKind";
+            readonly tag: PathKind_Tags.DirectPunched;
+        };
+    };
+    Relayed: {
+        new (inner: {
+            relayPeerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            relayPeerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+}>;
+/**
+ * Kind of usable connection path.
+ */
+export type PathKind = InstanceType<typeof PathKind['DirectDialed' | 'DirectPunched' | 'Relayed']>;
+export declare 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",
+    StreamWriteAccepted = "StreamWriteAccepted",
+    StreamWriteStopped = "StreamWriteStopped",
+    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 declare const P2pEvent: Readonly<{
+    instanceOf: (obj: any) => obj is P2pEvent;
+    EventsDropped: {
+        new (inner: {
+            dropped: bigint;
+            totalDropped: bigint;
+            terminalConnectIds: Array<bigint>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            dropped: bigint;
+            totalDropped: bigint;
+            terminalConnectIds: Array<bigint>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
+    DriverFailed: {
+        new (inner: {
+            kind: DriverFailureKind;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            kind: DriverFailureKind;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ConnectionEstablished: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ConnectionClosed: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ConnectionReplaced: {
+        new (inner: {
+            peerId: string;
+            oldConnId: bigint;
+            newConnId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            oldConnId: bigint;
+            newConnId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerReady: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            protocols: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            protocols: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
+    IdentifyReceived: {
+        new (inner: {
+            peerId: string;
+            info: IdentifyInfo;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            info: IdentifyInfo;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PingRttMeasured: {
+        new (inner: {
+            peerId: string;
+            rttMs: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            rttMs: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PingTimeout: {
+        new (inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    StreamReady: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            protocolId: string;
+            initiatedLocally: boolean;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            protocolId: string;
+            initiatedLocally: boolean;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    StreamData: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            data: ArrayBuffer;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            data: ArrayBuffer;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    StreamWriteAccepted: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteAccepted;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteAccepted;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteAccepted;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+            }>;
+        };
+    };
+    StreamWriteStopped: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            errorCode: bigint;
+        }): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteStopped;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+                errorCode: bigint;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+            errorCode: bigint;
+        }): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteStopped;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+                errorCode: bigint;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "P2pEvent";
+            readonly tag: P2pEvent_Tags.StreamWriteStopped;
+            readonly inner: Readonly<{
+                peerId: string;
+                connId: bigint;
+                streamId: bigint;
+                errorCode: bigint;
+            }>;
+        };
+    };
+    StreamRemoteWriteClosed: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    StreamClosed: {
+        new (inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            connId: bigint;
+            streamId: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    EndpointError: {
+        new (inner: {
+            kind: EndpointErrorKind;
+            peerId?: string;
+            connId?: bigint;
+            streamId?: bigint;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            kind: EndpointErrorKind;
+            peerId?: string;
+            connId?: bigint;
+            streamId?: bigint;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ReachabilityChanged: {
+        new (inner: {
+            previous: Reachability;
+            current: Reachability;
+            confirmedAddrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            previous: Reachability;
+            current: Reachability;
+            confirmedAddrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
+    PublicAddressesChanged: {
+        new (inner: {
+            addrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            addrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
+    RelayReserved: {
+        new (inner: {
+            relayPeerId: string;
+            expiresUnixSecs?: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            relayPeerId: string;
+            expiresUnixSecs?: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    RelayReservationLost: {
+        new (inner: {
+            relayPeerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            relayPeerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PathEstablished: {
+        new (inner: {
+            connectId: bigint;
+            peerId: string;
+            connId: bigint;
+            path: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            connectId: bigint;
+            peerId: string;
+            connId: bigint;
+            path: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    InboundPathEstablished: {
+        new (inner: {
+            peerId: string;
+            path: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            path: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PathUpgraded: {
+        new (inner: {
+            connectId: bigint;
+            peerId: string;
+            from: PathKind;
+            to: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            connectId: bigint;
+            peerId: string;
+            from: PathKind;
+            to: PathKind;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    HolePunchFailed: {
+        new (inner: {
+            connectId: bigint;
+            attempt: number;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            connectId: bigint;
+            attempt: number;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ConnectFailed: {
+        new (inner: {
+            connectId: bigint;
+            peerId: string;
+            kind: NatErrorKind;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            connectId: bigint;
+            peerId: string;
+            kind: NatErrorKind;
+            detail: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    ConnectCancelled: {
+        new (inner: {
+            connectId: bigint;
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            connectId: bigint;
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    InboundDirectUpgrade: {
+        new (inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    Message: {
+        new (inner: {
+            fromPeerId: string;
+            topics: Array<string>;
+            data: ArrayBuffer;
+            seqno: ArrayBuffer;
+            signed: boolean;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            fromPeerId: string;
+            topics: Array<string>;
+            data: ArrayBuffer;
+            seqno: ArrayBuffer;
+            signed: boolean;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerSubscribed: {
+        new (inner: {
+            peerId: string;
+            topic: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            topic: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerUnsubscribed: {
+        new (inner: {
+            peerId: string;
+            topic: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            topic: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    GossipsubOutboundFailure: {
+        new (inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    GossipsubProtocolViolation: {
+        new (inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerDiscovered: {
+        new (inner: {
+            peerId: string;
+            addrs: Array<string>;
+            source: DiscoverySource;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            addrs: Array<string>;
+            source: DiscoverySource;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerUpdated: {
+        new (inner: {
+            peerId: string;
+            addrs: Array<string>;
+            source: DiscoverySource;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            addrs: Array<string>;
+            source: DiscoverySource;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    PeerExpired: {
+        new (inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    DiscoveryDialFailed: {
+        new (inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId: string;
+            reason: string;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    DiscoveryProtocolViolation: {
+        new (inner: {
+            peerId?: string;
+            source: DiscoverySource;
+            reason: string;
+            suppressed: number;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            peerId?: string;
+            source: DiscoverySource;
+            reason: string;
+            suppressed: number;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+}>;
+/**
+ * Event delivered by the native endpoint driver.
+ */
+export type P2pEvent = InstanceType<typeof P2pEvent['EventsDropped' | 'DriverFailed' | 'ConnectionEstablished' | 'ConnectionClosed' | 'ConnectionReplaced' | 'PeerReady' | 'IdentifyReceived' | 'PingRttMeasured' | 'PingTimeout' | 'StreamReady' | 'StreamData' | 'StreamWriteAccepted' | 'StreamWriteStopped' | 'StreamRemoteWriteClosed' | 'StreamClosed' | 'EndpointError' | 'ReachabilityChanged' | 'PublicAddressesChanged' | 'RelayReserved' | 'RelayReservationLost' | 'PathEstablished' | 'InboundPathEstablished' | 'PathUpgraded' | 'HolePunchFailed' | 'ConnectFailed' | 'ConnectCancelled' | 'InboundDirectUpgrade' | 'Message' | 'PeerSubscribed' | 'PeerUnsubscribed' | 'GossipsubOutboundFailure' | 'GossipsubProtocolViolation' | 'PeerDiscovered' | 'PeerUpdated' | 'PeerExpired' | 'DiscoveryDialFailed' | 'DiscoveryProtocolViolation']>;
+/**
+ * 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.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default: Readonly<{
+    initialize: typeof uniffiEnsureInitialized;
+    converters: {
+        FfiConverterTypeConnectTarget: {
+            readFromCursor(c: Cursor): ConnectTarget;
+            writeIntoCursor(value: ConnectTarget, c: Cursor): void;
+            allocationSize(value: ConnectTarget): number;
+            lift(value: UniffiByteArray): ConnectTarget;
+            lower(value: ConnectTarget, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeConnectionInfo: {
+            readFromCursor(c: Cursor): ConnectionInfo;
+            writeIntoCursor(value: ConnectionInfo, c: Cursor): void;
+            allocationSize(value: ConnectionInfo): number;
+            lift(value: UniffiByteArray): ConnectionInfo;
+            lower(value: ConnectionInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDiscoveryOptions: {
+            readFromCursor(c: Cursor): DiscoveryOptions;
+            writeIntoCursor(value: DiscoveryOptions, c: Cursor): void;
+            allocationSize(value: DiscoveryOptions): number;
+            lift(value: UniffiByteArray): DiscoveryOptions;
+            lower(value: DiscoveryOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDiscoverySource: {
+            readFromCursor(c: Cursor): DiscoverySource;
+            writeIntoCursor(value: DiscoverySource, c: Cursor): void;
+            allocationSize(value: DiscoverySource): number;
+            lift(value: UniffiByteArray): DiscoverySource;
+            lower(value: DiscoverySource, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverFailureKind: {
+            readFromCursor(c: Cursor): DriverFailureKind;
+            writeIntoCursor(value: DriverFailureKind, c: Cursor): void;
+            allocationSize(value: DriverFailureKind): number;
+            lift(value: UniffiByteArray): DriverFailureKind;
+            lower(value: DriverFailureKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEndpointConfig: {
+            readFromCursor(c: Cursor): EndpointConfig;
+            writeIntoCursor(value: EndpointConfig, c: Cursor): void;
+            allocationSize(value: EndpointConfig): number;
+            lift(value: UniffiByteArray): EndpointConfig;
+            lower(value: EndpointConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEndpointErrorKind: {
+            readFromCursor(c: Cursor): EndpointErrorKind;
+            writeIntoCursor(value: EndpointErrorKind, c: Cursor): void;
+            allocationSize(value: EndpointErrorKind): number;
+            lift(value: UniffiByteArray): EndpointErrorKind;
+            lower(value: EndpointErrorKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeFfiError: {
+            readFromCursor(c: Cursor): FfiError;
+            writeIntoCursor(value: FfiError, c: Cursor): void;
+            allocationSize(value: FfiError): number;
+            lift(value: UniffiByteArray): FfiError;
+            lower(value: FfiError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeIdentifyInfo: {
+            readFromCursor(c: Cursor): IdentifyInfo;
+            writeIntoCursor(value: IdentifyInfo, c: Cursor): void;
+            allocationSize(value: IdentifyInfo): number;
+            lift(value: UniffiByteArray): IdentifyInfo;
+            lower(value: IdentifyInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeKnownPeerInfo: {
+            readFromCursor(c: Cursor): KnownPeerInfo;
+            writeIntoCursor(value: KnownPeerInfo, c: Cursor): void;
+            allocationSize(value: KnownPeerInfo): number;
+            lift(value: UniffiByteArray): KnownPeerInfo;
+            lower(value: KnownPeerInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeMdnsOptions: {
+            readFromCursor(c: Cursor): MdnsOptions;
+            writeIntoCursor(value: MdnsOptions, c: Cursor): void;
+            allocationSize(value: MdnsOptions): number;
+            lift(value: UniffiByteArray): MdnsOptions;
+            lower(value: MdnsOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeNatErrorKind: {
+            readFromCursor(c: Cursor): NatErrorKind;
+            writeIntoCursor(value: NatErrorKind, c: Cursor): void;
+            allocationSize(value: NatErrorKind): number;
+            lift(value: UniffiByteArray): NatErrorKind;
+            lower(value: NatErrorKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOpenStreamResult: {
+            readFromCursor(c: Cursor): OpenStreamResult;
+            writeIntoCursor(value: OpenStreamResult, c: Cursor): void;
+            allocationSize(value: OpenStreamResult): number;
+            lift(value: UniffiByteArray): OpenStreamResult;
+            lower(value: OpenStreamResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeP2pEvent: {
+            readFromCursor(c: Cursor): P2pEvent;
+            writeIntoCursor(value: P2pEvent, c: Cursor): void;
+            allocationSize(value: P2pEvent): number;
+            lift(value: UniffiByteArray): P2pEvent;
+            lower(value: P2pEvent, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePathKind: {
+            readFromCursor(c: Cursor): PathKind;
+            writeIntoCursor(value: PathKind, c: Cursor): void;
+            allocationSize(value: PathKind): number;
+            lift(value: UniffiByteArray): PathKind;
+            lower(value: PathKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeReachability: {
+            readFromCursor(c: Cursor): Reachability;
+            writeIntoCursor(value: Reachability, c: Cursor): void;
+            allocationSize(value: Reachability): number;
+            lift(value: UniffiByteArray): Reachability;
+            lower(value: Reachability, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeRelayReservationInfo: {
+            readFromCursor(c: Cursor): RelayReservationInfo;
+            writeIntoCursor(value: RelayReservationInfo, c: Cursor): void;
+            allocationSize(value: RelayReservationInfo): number;
+            lift(value: UniffiByteArray): RelayReservationInfo;
+            lower(value: RelayReservationInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;
+//# sourceMappingURL=minip2p_ffi_core.d.ts.map