@livekit/rtc-node 0.0.2 → 0.0.3

package/dist/proto/room_pb.d.ts

@@ -0,0 +1,1479 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
+import { OwnedParticipant } from "./participant_pb.js";
+import { OwnedTrack, OwnedTrackPublication, TrackSource } from "./track_pb.js";
+import { VideoCodec } from "./video_frame_pb.js";
+import { E2eeOptions, EncryptionState } from "./e2ee_pb.js";
+import { FfiOwnedHandle } from "./handle_pb.js";
+/**
+ * @generated from enum livekit.proto.IceTransportType
+ */
+export declare enum IceTransportType {
+    /**
+     * @generated from enum value: TRANSPORT_RELAY = 0;
+     */
+    TRANSPORT_RELAY = 0,
+    /**
+     * @generated from enum value: TRANSPORT_NOHOST = 1;
+     */
+    TRANSPORT_NOHOST = 1,
+    /**
+     * @generated from enum value: TRANSPORT_ALL = 2;
+     */
+    TRANSPORT_ALL = 2
+}
+/**
+ * @generated from enum livekit.proto.ContinualGatheringPolicy
+ */
+export declare enum ContinualGatheringPolicy {
+    /**
+     * @generated from enum value: GATHER_ONCE = 0;
+     */
+    GATHER_ONCE = 0,
+    /**
+     * @generated from enum value: GATHER_CONTINUALLY = 1;
+     */
+    GATHER_CONTINUALLY = 1
+}
+/**
+ * @generated from enum livekit.proto.ConnectionQuality
+ */
+export declare enum ConnectionQuality {
+    /**
+     * @generated from enum value: QUALITY_POOR = 0;
+     */
+    QUALITY_POOR = 0,
+    /**
+     * @generated from enum value: QUALITY_GOOD = 1;
+     */
+    QUALITY_GOOD = 1,
+    /**
+     * @generated from enum value: QUALITY_EXCELLENT = 2;
+     */
+    QUALITY_EXCELLENT = 2
+}
+/**
+ * @generated from enum livekit.proto.ConnectionState
+ */
+export declare enum ConnectionState {
+    /**
+     * @generated from enum value: CONN_DISCONNECTED = 0;
+     */
+    CONN_DISCONNECTED = 0,
+    /**
+     * @generated from enum value: CONN_CONNECTED = 1;
+     */
+    CONN_CONNECTED = 1,
+    /**
+     * @generated from enum value: CONN_RECONNECTING = 2;
+     */
+    CONN_RECONNECTING = 2
+}
+/**
+ * @generated from enum livekit.proto.DataPacketKind
+ */
+export declare enum DataPacketKind {
+    /**
+     * @generated from enum value: KIND_LOSSY = 0;
+     */
+    KIND_LOSSY = 0,
+    /**
+     * @generated from enum value: KIND_RELIABLE = 1;
+     */
+    KIND_RELIABLE = 1
+}
+/**
+ * Connect to a new LiveKit room
+ *
+ * @generated from message livekit.proto.ConnectRequest
+ */
+export declare class ConnectRequest extends Message<ConnectRequest> {
+    /**
+     * @generated from field: string url = 1;
+     */
+    url: string;
+    /**
+     * @generated from field: string token = 2;
+     */
+    token: string;
+    /**
+     * @generated from field: livekit.proto.RoomOptions options = 3;
+     */
+    options?: RoomOptions;
+    constructor(data?: PartialMessage<ConnectRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectRequest;
+    static equals(a: ConnectRequest | PlainMessage<ConnectRequest> | undefined, b: ConnectRequest | PlainMessage<ConnectRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ConnectResponse
+ */
+export declare class ConnectResponse extends Message<ConnectResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<ConnectResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectResponse;
+    static equals(a: ConnectResponse | PlainMessage<ConnectResponse> | undefined, b: ConnectResponse | PlainMessage<ConnectResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ConnectCallback
+ */
+export declare class ConnectCallback extends Message<ConnectCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    /**
+     * @generated from field: optional string error = 2;
+     */
+    error?: string;
+    /**
+     * @generated from field: livekit.proto.OwnedRoom room = 3;
+     */
+    room?: OwnedRoom;
+    /**
+     * @generated from field: livekit.proto.OwnedParticipant local_participant = 4;
+     */
+    localParticipant?: OwnedParticipant;
+    /**
+     * @generated from field: repeated livekit.proto.ConnectCallback.ParticipantWithTracks participants = 5;
+     */
+    participants: ConnectCallback_ParticipantWithTracks[];
+    constructor(data?: PartialMessage<ConnectCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectCallback;
+    static equals(a: ConnectCallback | PlainMessage<ConnectCallback> | undefined, b: ConnectCallback | PlainMessage<ConnectCallback> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ConnectCallback.ParticipantWithTracks
+ */
+export declare class ConnectCallback_ParticipantWithTracks extends Message<ConnectCallback_ParticipantWithTracks> {
+    /**
+     * @generated from field: livekit.proto.OwnedParticipant participant = 1;
+     */
+    participant?: OwnedParticipant;
+    /**
+     * TrackInfo are not needed here, if we're subscribed to a track, the FfiServer will send
+     * a TrackSubscribed event
+     *
+     * @generated from field: repeated livekit.proto.OwnedTrackPublication publications = 2;
+     */
+    publications: OwnedTrackPublication[];
+    constructor(data?: PartialMessage<ConnectCallback_ParticipantWithTracks>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectCallback.ParticipantWithTracks";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectCallback_ParticipantWithTracks;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectCallback_ParticipantWithTracks;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectCallback_ParticipantWithTracks;
+    static equals(a: ConnectCallback_ParticipantWithTracks | PlainMessage<ConnectCallback_ParticipantWithTracks> | undefined, b: ConnectCallback_ParticipantWithTracks | PlainMessage<ConnectCallback_ParticipantWithTracks> | undefined): boolean;
+}
+/**
+ * Disconnect from the a room
+ *
+ * @generated from message livekit.proto.DisconnectRequest
+ */
+export declare class DisconnectRequest extends Message<DisconnectRequest> {
+    /**
+     * @generated from field: uint64 room_handle = 1;
+     */
+    roomHandle: bigint;
+    constructor(data?: PartialMessage<DisconnectRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.DisconnectRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisconnectRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisconnectRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisconnectRequest;
+    static equals(a: DisconnectRequest | PlainMessage<DisconnectRequest> | undefined, b: DisconnectRequest | PlainMessage<DisconnectRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.DisconnectResponse
+ */
+export declare class DisconnectResponse extends Message<DisconnectResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<DisconnectResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.DisconnectResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisconnectResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisconnectResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisconnectResponse;
+    static equals(a: DisconnectResponse | PlainMessage<DisconnectResponse> | undefined, b: DisconnectResponse | PlainMessage<DisconnectResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.DisconnectCallback
+ */
+export declare class DisconnectCallback extends Message<DisconnectCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<DisconnectCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.DisconnectCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisconnectCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisconnectCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisconnectCallback;
+    static equals(a: DisconnectCallback | PlainMessage<DisconnectCallback> | undefined, b: DisconnectCallback | PlainMessage<DisconnectCallback> | undefined): boolean;
+}
+/**
+ * Publish a track to the room
+ *
+ * @generated from message livekit.proto.PublishTrackRequest
+ */
+export declare class PublishTrackRequest extends Message<PublishTrackRequest> {
+    /**
+     * @generated from field: uint64 local_participant_handle = 1;
+     */
+    localParticipantHandle: bigint;
+    /**
+     * @generated from field: uint64 track_handle = 2;
+     */
+    trackHandle: bigint;
+    /**
+     * @generated from field: livekit.proto.TrackPublishOptions options = 3;
+     */
+    options?: TrackPublishOptions;
+    constructor(data?: PartialMessage<PublishTrackRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishTrackRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTrackRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTrackRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTrackRequest;
+    static equals(a: PublishTrackRequest | PlainMessage<PublishTrackRequest> | undefined, b: PublishTrackRequest | PlainMessage<PublishTrackRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.PublishTrackResponse
+ */
+export declare class PublishTrackResponse extends Message<PublishTrackResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<PublishTrackResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishTrackResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTrackResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTrackResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTrackResponse;
+    static equals(a: PublishTrackResponse | PlainMessage<PublishTrackResponse> | undefined, b: PublishTrackResponse | PlainMessage<PublishTrackResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.PublishTrackCallback
+ */
+export declare class PublishTrackCallback extends Message<PublishTrackCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    /**
+     * @generated from field: optional string error = 2;
+     */
+    error?: string;
+    /**
+     * @generated from field: livekit.proto.OwnedTrackPublication publication = 3;
+     */
+    publication?: OwnedTrackPublication;
+    constructor(data?: PartialMessage<PublishTrackCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishTrackCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTrackCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTrackCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTrackCallback;
+    static equals(a: PublishTrackCallback | PlainMessage<PublishTrackCallback> | undefined, b: PublishTrackCallback | PlainMessage<PublishTrackCallback> | undefined): boolean;
+}
+/**
+ * Unpublish a track from the room
+ *
+ * @generated from message livekit.proto.UnpublishTrackRequest
+ */
+export declare class UnpublishTrackRequest extends Message<UnpublishTrackRequest> {
+    /**
+     * @generated from field: uint64 local_participant_handle = 1;
+     */
+    localParticipantHandle: bigint;
+    /**
+     * @generated from field: string track_sid = 2;
+     */
+    trackSid: string;
+    /**
+     * @generated from field: bool stop_on_unpublish = 3;
+     */
+    stopOnUnpublish: boolean;
+    constructor(data?: PartialMessage<UnpublishTrackRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UnpublishTrackRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UnpublishTrackRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UnpublishTrackRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UnpublishTrackRequest;
+    static equals(a: UnpublishTrackRequest | PlainMessage<UnpublishTrackRequest> | undefined, b: UnpublishTrackRequest | PlainMessage<UnpublishTrackRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UnpublishTrackResponse
+ */
+export declare class UnpublishTrackResponse extends Message<UnpublishTrackResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<UnpublishTrackResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UnpublishTrackResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UnpublishTrackResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UnpublishTrackResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UnpublishTrackResponse;
+    static equals(a: UnpublishTrackResponse | PlainMessage<UnpublishTrackResponse> | undefined, b: UnpublishTrackResponse | PlainMessage<UnpublishTrackResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UnpublishTrackCallback
+ */
+export declare class UnpublishTrackCallback extends Message<UnpublishTrackCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    /**
+     * @generated from field: optional string error = 2;
+     */
+    error?: string;
+    constructor(data?: PartialMessage<UnpublishTrackCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UnpublishTrackCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UnpublishTrackCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UnpublishTrackCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UnpublishTrackCallback;
+    static equals(a: UnpublishTrackCallback | PlainMessage<UnpublishTrackCallback> | undefined, b: UnpublishTrackCallback | PlainMessage<UnpublishTrackCallback> | undefined): boolean;
+}
+/**
+ * Publish data to other participants
+ *
+ * @generated from message livekit.proto.PublishDataRequest
+ */
+export declare class PublishDataRequest extends Message<PublishDataRequest> {
+    /**
+     * @generated from field: uint64 local_participant_handle = 1;
+     */
+    localParticipantHandle: bigint;
+    /**
+     * @generated from field: uint64 data_ptr = 2;
+     */
+    dataPtr: bigint;
+    /**
+     * @generated from field: uint64 data_len = 3;
+     */
+    dataLen: bigint;
+    /**
+     * @generated from field: livekit.proto.DataPacketKind kind = 4;
+     */
+    kind: DataPacketKind;
+    /**
+     * destination
+     *
+     * @generated from field: repeated string destination_sids = 5;
+     */
+    destinationSids: string[];
+    constructor(data?: PartialMessage<PublishDataRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishDataRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishDataRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishDataRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishDataRequest;
+    static equals(a: PublishDataRequest | PlainMessage<PublishDataRequest> | undefined, b: PublishDataRequest | PlainMessage<PublishDataRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.PublishDataResponse
+ */
+export declare class PublishDataResponse extends Message<PublishDataResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<PublishDataResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishDataResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishDataResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishDataResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishDataResponse;
+    static equals(a: PublishDataResponse | PlainMessage<PublishDataResponse> | undefined, b: PublishDataResponse | PlainMessage<PublishDataResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.PublishDataCallback
+ */
+export declare class PublishDataCallback extends Message<PublishDataCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    /**
+     * @generated from field: optional string error = 2;
+     */
+    error?: string;
+    constructor(data?: PartialMessage<PublishDataCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.PublishDataCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishDataCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishDataCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishDataCallback;
+    static equals(a: PublishDataCallback | PlainMessage<PublishDataCallback> | undefined, b: PublishDataCallback | PlainMessage<PublishDataCallback> | undefined): boolean;
+}
+/**
+ * Change the local participant's metadata
+ *
+ * @generated from message livekit.proto.UpdateLocalMetadataRequest
+ */
+export declare class UpdateLocalMetadataRequest extends Message<UpdateLocalMetadataRequest> {
+    /**
+     * @generated from field: uint64 local_participant_handle = 1;
+     */
+    localParticipantHandle: bigint;
+    /**
+     * @generated from field: string metadata = 2;
+     */
+    metadata: string;
+    constructor(data?: PartialMessage<UpdateLocalMetadataRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalMetadataRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalMetadataRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalMetadataRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalMetadataRequest;
+    static equals(a: UpdateLocalMetadataRequest | PlainMessage<UpdateLocalMetadataRequest> | undefined, b: UpdateLocalMetadataRequest | PlainMessage<UpdateLocalMetadataRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UpdateLocalMetadataResponse
+ */
+export declare class UpdateLocalMetadataResponse extends Message<UpdateLocalMetadataResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<UpdateLocalMetadataResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalMetadataResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalMetadataResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalMetadataResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalMetadataResponse;
+    static equals(a: UpdateLocalMetadataResponse | PlainMessage<UpdateLocalMetadataResponse> | undefined, b: UpdateLocalMetadataResponse | PlainMessage<UpdateLocalMetadataResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UpdateLocalMetadataCallback
+ */
+export declare class UpdateLocalMetadataCallback extends Message<UpdateLocalMetadataCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<UpdateLocalMetadataCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalMetadataCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalMetadataCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalMetadataCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalMetadataCallback;
+    static equals(a: UpdateLocalMetadataCallback | PlainMessage<UpdateLocalMetadataCallback> | undefined, b: UpdateLocalMetadataCallback | PlainMessage<UpdateLocalMetadataCallback> | undefined): boolean;
+}
+/**
+ * Change the local participant's name
+ *
+ * @generated from message livekit.proto.UpdateLocalNameRequest
+ */
+export declare class UpdateLocalNameRequest extends Message<UpdateLocalNameRequest> {
+    /**
+     * @generated from field: uint64 local_participant_handle = 1;
+     */
+    localParticipantHandle: bigint;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    constructor(data?: PartialMessage<UpdateLocalNameRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalNameRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalNameRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalNameRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalNameRequest;
+    static equals(a: UpdateLocalNameRequest | PlainMessage<UpdateLocalNameRequest> | undefined, b: UpdateLocalNameRequest | PlainMessage<UpdateLocalNameRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UpdateLocalNameResponse
+ */
+export declare class UpdateLocalNameResponse extends Message<UpdateLocalNameResponse> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<UpdateLocalNameResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalNameResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalNameResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalNameResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalNameResponse;
+    static equals(a: UpdateLocalNameResponse | PlainMessage<UpdateLocalNameResponse> | undefined, b: UpdateLocalNameResponse | PlainMessage<UpdateLocalNameResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.UpdateLocalNameCallback
+ */
+export declare class UpdateLocalNameCallback extends Message<UpdateLocalNameCallback> {
+    /**
+     * @generated from field: uint64 async_id = 1;
+     */
+    asyncId: bigint;
+    constructor(data?: PartialMessage<UpdateLocalNameCallback>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.UpdateLocalNameCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateLocalNameCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateLocalNameCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateLocalNameCallback;
+    static equals(a: UpdateLocalNameCallback | PlainMessage<UpdateLocalNameCallback> | undefined, b: UpdateLocalNameCallback | PlainMessage<UpdateLocalNameCallback> | undefined): boolean;
+}
+/**
+ * Change the "desire" to subs2ribe to a track
+ *
+ * @generated from message livekit.proto.SetSubscribedRequest
+ */
+export declare class SetSubscribedRequest extends Message<SetSubscribedRequest> {
+    /**
+     * @generated from field: bool subscribe = 1;
+     */
+    subscribe: boolean;
+    /**
+     * @generated from field: uint64 publication_handle = 2;
+     */
+    publicationHandle: bigint;
+    constructor(data?: PartialMessage<SetSubscribedRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.SetSubscribedRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetSubscribedRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetSubscribedRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetSubscribedRequest;
+    static equals(a: SetSubscribedRequest | PlainMessage<SetSubscribedRequest> | undefined, b: SetSubscribedRequest | PlainMessage<SetSubscribedRequest> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.SetSubscribedResponse
+ */
+export declare class SetSubscribedResponse extends Message<SetSubscribedResponse> {
+    constructor(data?: PartialMessage<SetSubscribedResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.SetSubscribedResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetSubscribedResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetSubscribedResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetSubscribedResponse;
+    static equals(a: SetSubscribedResponse | PlainMessage<SetSubscribedResponse> | undefined, b: SetSubscribedResponse | PlainMessage<SetSubscribedResponse> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.VideoEncoding
+ */
+export declare class VideoEncoding extends Message<VideoEncoding> {
+    /**
+     * @generated from field: uint64 max_bitrate = 1;
+     */
+    maxBitrate: bigint;
+    /**
+     * @generated from field: double max_framerate = 2;
+     */
+    maxFramerate: number;
+    constructor(data?: PartialMessage<VideoEncoding>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.VideoEncoding";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncoding;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncoding;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncoding;
+    static equals(a: VideoEncoding | PlainMessage<VideoEncoding> | undefined, b: VideoEncoding | PlainMessage<VideoEncoding> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.AudioEncoding
+ */
+export declare class AudioEncoding extends Message<AudioEncoding> {
+    /**
+     * @generated from field: uint64 max_bitrate = 1;
+     */
+    maxBitrate: bigint;
+    constructor(data?: PartialMessage<AudioEncoding>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.AudioEncoding";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncoding;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncoding;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncoding;
+    static equals(a: AudioEncoding | PlainMessage<AudioEncoding> | undefined, b: AudioEncoding | PlainMessage<AudioEncoding> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackPublishOptions
+ */
+export declare class TrackPublishOptions extends Message<TrackPublishOptions> {
+    /**
+     * encodings are optional
+     *
+     * @generated from field: livekit.proto.VideoEncoding video_encoding = 1;
+     */
+    videoEncoding?: VideoEncoding;
+    /**
+     * @generated from field: livekit.proto.AudioEncoding audio_encoding = 2;
+     */
+    audioEncoding?: AudioEncoding;
+    /**
+     * @generated from field: livekit.proto.VideoCodec video_codec = 3;
+     */
+    videoCodec: VideoCodec;
+    /**
+     * @generated from field: bool dtx = 4;
+     */
+    dtx: boolean;
+    /**
+     * @generated from field: bool red = 5;
+     */
+    red: boolean;
+    /**
+     * @generated from field: bool simulcast = 6;
+     */
+    simulcast: boolean;
+    /**
+     * @generated from field: livekit.proto.TrackSource source = 7;
+     */
+    source: TrackSource;
+    constructor(data?: PartialMessage<TrackPublishOptions>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackPublishOptions";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackPublishOptions;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackPublishOptions;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackPublishOptions;
+    static equals(a: TrackPublishOptions | PlainMessage<TrackPublishOptions> | undefined, b: TrackPublishOptions | PlainMessage<TrackPublishOptions> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.IceServer
+ */
+export declare class IceServer extends Message<IceServer> {
+    /**
+     * @generated from field: repeated string urls = 1;
+     */
+    urls: string[];
+    /**
+     * @generated from field: string username = 2;
+     */
+    username: string;
+    /**
+     * @generated from field: string password = 3;
+     */
+    password: string;
+    constructor(data?: PartialMessage<IceServer>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.IceServer";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IceServer;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IceServer;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IceServer;
+    static equals(a: IceServer | PlainMessage<IceServer> | undefined, b: IceServer | PlainMessage<IceServer> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RtcConfig
+ */
+export declare class RtcConfig extends Message<RtcConfig> {
+    /**
+     * @generated from field: optional livekit.proto.IceTransportType ice_transport_type = 1;
+     */
+    iceTransportType?: IceTransportType;
+    /**
+     * @generated from field: optional livekit.proto.ContinualGatheringPolicy continual_gathering_policy = 2;
+     */
+    continualGatheringPolicy?: ContinualGatheringPolicy;
+    /**
+     * empty fallback to default
+     *
+     * @generated from field: repeated livekit.proto.IceServer ice_servers = 3;
+     */
+    iceServers: IceServer[];
+    constructor(data?: PartialMessage<RtcConfig>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RtcConfig";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtcConfig;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtcConfig;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtcConfig;
+    static equals(a: RtcConfig | PlainMessage<RtcConfig> | undefined, b: RtcConfig | PlainMessage<RtcConfig> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RoomOptions
+ */
+export declare class RoomOptions extends Message<RoomOptions> {
+    /**
+     * @generated from field: bool auto_subscribe = 1;
+     */
+    autoSubscribe: boolean;
+    /**
+     * @generated from field: bool adaptive_stream = 2;
+     */
+    adaptiveStream: boolean;
+    /**
+     * @generated from field: bool dynacast = 3;
+     */
+    dynacast: boolean;
+    /**
+     * @generated from field: optional livekit.proto.E2eeOptions e2ee = 4;
+     */
+    e2ee?: E2eeOptions;
+    /**
+     * allow to setup a custom RtcConfiguration
+     *
+     * @generated from field: optional livekit.proto.RtcConfig rtc_config = 5;
+     */
+    rtcConfig?: RtcConfig;
+    /**
+     * @generated from field: uint32 join_retries = 6;
+     */
+    joinRetries: number;
+    constructor(data?: PartialMessage<RoomOptions>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RoomOptions";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomOptions;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomOptions;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomOptions;
+    static equals(a: RoomOptions | PlainMessage<RoomOptions> | undefined, b: RoomOptions | PlainMessage<RoomOptions> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.BufferInfo
+ */
+export declare class BufferInfo extends Message<BufferInfo> {
+    /**
+     * @generated from field: uint64 data_ptr = 1;
+     */
+    dataPtr: bigint;
+    /**
+     * @generated from field: uint64 data_len = 2;
+     */
+    dataLen: bigint;
+    constructor(data?: PartialMessage<BufferInfo>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.BufferInfo";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BufferInfo;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BufferInfo;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BufferInfo;
+    static equals(a: BufferInfo | PlainMessage<BufferInfo> | undefined, b: BufferInfo | PlainMessage<BufferInfo> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.OwnedBuffer
+ */
+export declare class OwnedBuffer extends Message<OwnedBuffer> {
+    /**
+     * @generated from field: livekit.proto.FfiOwnedHandle handle = 1;
+     */
+    handle?: FfiOwnedHandle;
+    /**
+     * @generated from field: livekit.proto.BufferInfo data = 2;
+     */
+    data?: BufferInfo;
+    constructor(data?: PartialMessage<OwnedBuffer>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.OwnedBuffer";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OwnedBuffer;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OwnedBuffer;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OwnedBuffer;
+    static equals(a: OwnedBuffer | PlainMessage<OwnedBuffer> | undefined, b: OwnedBuffer | PlainMessage<OwnedBuffer> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RoomEvent
+ */
+export declare class RoomEvent extends Message<RoomEvent> {
+    /**
+     * @generated from field: uint64 room_handle = 1;
+     */
+    roomHandle: bigint;
+    /**
+     * @generated from oneof livekit.proto.RoomEvent.message
+     */
+    message: {
+        /**
+         * @generated from field: livekit.proto.ParticipantConnected participant_connected = 2;
+         */
+        value: ParticipantConnected;
+        case: "participantConnected";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ParticipantDisconnected participant_disconnected = 3;
+         */
+        value: ParticipantDisconnected;
+        case: "participantDisconnected";
+    } | {
+        /**
+         * @generated from field: livekit.proto.LocalTrackPublished local_track_published = 4;
+         */
+        value: LocalTrackPublished;
+        case: "localTrackPublished";
+    } | {
+        /**
+         * @generated from field: livekit.proto.LocalTrackUnpublished local_track_unpublished = 5;
+         */
+        value: LocalTrackUnpublished;
+        case: "localTrackUnpublished";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackPublished track_published = 6;
+         */
+        value: TrackPublished;
+        case: "trackPublished";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackUnpublished track_unpublished = 7;
+         */
+        value: TrackUnpublished;
+        case: "trackUnpublished";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackSubscribed track_subscribed = 8;
+         */
+        value: TrackSubscribed;
+        case: "trackSubscribed";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackUnsubscribed track_unsubscribed = 9;
+         */
+        value: TrackUnsubscribed;
+        case: "trackUnsubscribed";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackSubscriptionFailed track_subscription_failed = 10;
+         */
+        value: TrackSubscriptionFailed;
+        case: "trackSubscriptionFailed";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackMuted track_muted = 11;
+         */
+        value: TrackMuted;
+        case: "trackMuted";
+    } | {
+        /**
+         * @generated from field: livekit.proto.TrackUnmuted track_unmuted = 12;
+         */
+        value: TrackUnmuted;
+        case: "trackUnmuted";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ActiveSpeakersChanged active_speakers_changed = 13;
+         */
+        value: ActiveSpeakersChanged;
+        case: "activeSpeakersChanged";
+    } | {
+        /**
+         * @generated from field: livekit.proto.RoomMetadataChanged room_metadata_changed = 14;
+         */
+        value: RoomMetadataChanged;
+        case: "roomMetadataChanged";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ParticipantMetadataChanged participant_metadata_changed = 15;
+         */
+        value: ParticipantMetadataChanged;
+        case: "participantMetadataChanged";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ParticipantNameChanged participant_name_changed = 16;
+         */
+        value: ParticipantNameChanged;
+        case: "participantNameChanged";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ConnectionQualityChanged connection_quality_changed = 17;
+         */
+        value: ConnectionQualityChanged;
+        case: "connectionQualityChanged";
+    } | {
+        /**
+         * @generated from field: livekit.proto.DataReceived data_received = 18;
+         */
+        value: DataReceived;
+        case: "dataReceived";
+    } | {
+        /**
+         * @generated from field: livekit.proto.ConnectionStateChanged connection_state_changed = 19;
+         */
+        value: ConnectionStateChanged;
+        case: "connectionStateChanged";
+    } | {
+        /**
+         * Connected connected = 20;
+         *
+         * @generated from field: livekit.proto.Disconnected disconnected = 21;
+         */
+        value: Disconnected;
+        case: "disconnected";
+    } | {
+        /**
+         * @generated from field: livekit.proto.Reconnecting reconnecting = 22;
+         */
+        value: Reconnecting;
+        case: "reconnecting";
+    } | {
+        /**
+         * @generated from field: livekit.proto.Reconnected reconnected = 23;
+         */
+        value: Reconnected;
+        case: "reconnected";
+    } | {
+        /**
+         * @generated from field: livekit.proto.E2eeStateChanged e2ee_state_changed = 24;
+         */
+        value: E2eeStateChanged;
+        case: "e2eeStateChanged";
+    } | {
+        /**
+         * The stream of room events has ended
+         *
+         * @generated from field: livekit.proto.RoomEOS eos = 25;
+         */
+        value: RoomEOS;
+        case: "eos";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<RoomEvent>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RoomEvent";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomEvent;
+    static equals(a: RoomEvent | PlainMessage<RoomEvent> | undefined, b: RoomEvent | PlainMessage<RoomEvent> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RoomInfo
+ */
+export declare class RoomInfo extends Message<RoomInfo> {
+    /**
+     * @generated from field: string sid = 1;
+     */
+    sid: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from field: string metadata = 3;
+     */
+    metadata: string;
+    constructor(data?: PartialMessage<RoomInfo>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RoomInfo";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomInfo;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomInfo;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomInfo;
+    static equals(a: RoomInfo | PlainMessage<RoomInfo> | undefined, b: RoomInfo | PlainMessage<RoomInfo> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.OwnedRoom
+ */
+export declare class OwnedRoom extends Message<OwnedRoom> {
+    /**
+     * @generated from field: livekit.proto.FfiOwnedHandle handle = 1;
+     */
+    handle?: FfiOwnedHandle;
+    /**
+     * @generated from field: livekit.proto.RoomInfo info = 2;
+     */
+    info?: RoomInfo;
+    constructor(data?: PartialMessage<OwnedRoom>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.OwnedRoom";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OwnedRoom;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OwnedRoom;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OwnedRoom;
+    static equals(a: OwnedRoom | PlainMessage<OwnedRoom> | undefined, b: OwnedRoom | PlainMessage<OwnedRoom> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ParticipantConnected
+ */
+export declare class ParticipantConnected extends Message<ParticipantConnected> {
+    /**
+     * @generated from field: livekit.proto.OwnedParticipant info = 1;
+     */
+    info?: OwnedParticipant;
+    constructor(data?: PartialMessage<ParticipantConnected>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ParticipantConnected";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantConnected;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantConnected;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantConnected;
+    static equals(a: ParticipantConnected | PlainMessage<ParticipantConnected> | undefined, b: ParticipantConnected | PlainMessage<ParticipantConnected> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ParticipantDisconnected
+ */
+export declare class ParticipantDisconnected extends Message<ParticipantDisconnected> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    constructor(data?: PartialMessage<ParticipantDisconnected>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ParticipantDisconnected";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantDisconnected;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantDisconnected;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantDisconnected;
+    static equals(a: ParticipantDisconnected | PlainMessage<ParticipantDisconnected> | undefined, b: ParticipantDisconnected | PlainMessage<ParticipantDisconnected> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.LocalTrackPublished
+ */
+export declare class LocalTrackPublished extends Message<LocalTrackPublished> {
+    /**
+     * The TrackPublicationInfo comes from the PublishTrack response
+     * and the FfiClient musts wait for it before firing this event
+     *
+     * @generated from field: string track_sid = 1;
+     */
+    trackSid: string;
+    constructor(data?: PartialMessage<LocalTrackPublished>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.LocalTrackPublished";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LocalTrackPublished;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LocalTrackPublished;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LocalTrackPublished;
+    static equals(a: LocalTrackPublished | PlainMessage<LocalTrackPublished> | undefined, b: LocalTrackPublished | PlainMessage<LocalTrackPublished> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.LocalTrackUnpublished
+ */
+export declare class LocalTrackUnpublished extends Message<LocalTrackUnpublished> {
+    /**
+     * @generated from field: string publication_sid = 1;
+     */
+    publicationSid: string;
+    constructor(data?: PartialMessage<LocalTrackUnpublished>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.LocalTrackUnpublished";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LocalTrackUnpublished;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LocalTrackUnpublished;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LocalTrackUnpublished;
+    static equals(a: LocalTrackUnpublished | PlainMessage<LocalTrackUnpublished> | undefined, b: LocalTrackUnpublished | PlainMessage<LocalTrackUnpublished> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackPublished
+ */
+export declare class TrackPublished extends Message<TrackPublished> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: livekit.proto.OwnedTrackPublication publication = 2;
+     */
+    publication?: OwnedTrackPublication;
+    constructor(data?: PartialMessage<TrackPublished>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackPublished";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackPublished;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackPublished;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackPublished;
+    static equals(a: TrackPublished | PlainMessage<TrackPublished> | undefined, b: TrackPublished | PlainMessage<TrackPublished> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackUnpublished
+ */
+export declare class TrackUnpublished extends Message<TrackUnpublished> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string publication_sid = 2;
+     */
+    publicationSid: string;
+    constructor(data?: PartialMessage<TrackUnpublished>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackUnpublished";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackUnpublished;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackUnpublished;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackUnpublished;
+    static equals(a: TrackUnpublished | PlainMessage<TrackUnpublished> | undefined, b: TrackUnpublished | PlainMessage<TrackUnpublished> | undefined): boolean;
+}
+/**
+ * Publication isn't needed for subscription events on the FFI
+ * The FFI will retrieve the publication using the Track sid
+ *
+ * @generated from message livekit.proto.TrackSubscribed
+ */
+export declare class TrackSubscribed extends Message<TrackSubscribed> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: livekit.proto.OwnedTrack track = 2;
+     */
+    track?: OwnedTrack;
+    constructor(data?: PartialMessage<TrackSubscribed>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackSubscribed";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackSubscribed;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackSubscribed;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackSubscribed;
+    static equals(a: TrackSubscribed | PlainMessage<TrackSubscribed> | undefined, b: TrackSubscribed | PlainMessage<TrackSubscribed> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackUnsubscribed
+ */
+export declare class TrackUnsubscribed extends Message<TrackUnsubscribed> {
+    /**
+     * The FFI language can dispose/remove the VideoSink here
+     *
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string track_sid = 2;
+     */
+    trackSid: string;
+    constructor(data?: PartialMessage<TrackUnsubscribed>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackUnsubscribed";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackUnsubscribed;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackUnsubscribed;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackUnsubscribed;
+    static equals(a: TrackUnsubscribed | PlainMessage<TrackUnsubscribed> | undefined, b: TrackUnsubscribed | PlainMessage<TrackUnsubscribed> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackSubscriptionFailed
+ */
+export declare class TrackSubscriptionFailed extends Message<TrackSubscriptionFailed> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string track_sid = 2;
+     */
+    trackSid: string;
+    /**
+     * @generated from field: string error = 3;
+     */
+    error: string;
+    constructor(data?: PartialMessage<TrackSubscriptionFailed>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackSubscriptionFailed";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackSubscriptionFailed;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackSubscriptionFailed;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackSubscriptionFailed;
+    static equals(a: TrackSubscriptionFailed | PlainMessage<TrackSubscriptionFailed> | undefined, b: TrackSubscriptionFailed | PlainMessage<TrackSubscriptionFailed> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackMuted
+ */
+export declare class TrackMuted extends Message<TrackMuted> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string track_sid = 2;
+     */
+    trackSid: string;
+    constructor(data?: PartialMessage<TrackMuted>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackMuted";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackMuted;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackMuted;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackMuted;
+    static equals(a: TrackMuted | PlainMessage<TrackMuted> | undefined, b: TrackMuted | PlainMessage<TrackMuted> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.TrackUnmuted
+ */
+export declare class TrackUnmuted extends Message<TrackUnmuted> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string track_sid = 2;
+     */
+    trackSid: string;
+    constructor(data?: PartialMessage<TrackUnmuted>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.TrackUnmuted";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackUnmuted;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrackUnmuted;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrackUnmuted;
+    static equals(a: TrackUnmuted | PlainMessage<TrackUnmuted> | undefined, b: TrackUnmuted | PlainMessage<TrackUnmuted> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.E2eeStateChanged
+ */
+export declare class E2eeStateChanged extends Message<E2eeStateChanged> {
+    /**
+     * Using sid instead of identity for ffi communication
+     *
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: livekit.proto.EncryptionState state = 2;
+     */
+    state: EncryptionState;
+    constructor(data?: PartialMessage<E2eeStateChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.E2eeStateChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): E2eeStateChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): E2eeStateChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): E2eeStateChanged;
+    static equals(a: E2eeStateChanged | PlainMessage<E2eeStateChanged> | undefined, b: E2eeStateChanged | PlainMessage<E2eeStateChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ActiveSpeakersChanged
+ */
+export declare class ActiveSpeakersChanged extends Message<ActiveSpeakersChanged> {
+    /**
+     * @generated from field: repeated string participant_sids = 1;
+     */
+    participantSids: string[];
+    constructor(data?: PartialMessage<ActiveSpeakersChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ActiveSpeakersChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ActiveSpeakersChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ActiveSpeakersChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ActiveSpeakersChanged;
+    static equals(a: ActiveSpeakersChanged | PlainMessage<ActiveSpeakersChanged> | undefined, b: ActiveSpeakersChanged | PlainMessage<ActiveSpeakersChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RoomMetadataChanged
+ */
+export declare class RoomMetadataChanged extends Message<RoomMetadataChanged> {
+    /**
+     * @generated from field: string metadata = 1;
+     */
+    metadata: string;
+    constructor(data?: PartialMessage<RoomMetadataChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RoomMetadataChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomMetadataChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomMetadataChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomMetadataChanged;
+    static equals(a: RoomMetadataChanged | PlainMessage<RoomMetadataChanged> | undefined, b: RoomMetadataChanged | PlainMessage<RoomMetadataChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ParticipantMetadataChanged
+ */
+export declare class ParticipantMetadataChanged extends Message<ParticipantMetadataChanged> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string metadata = 2;
+     */
+    metadata: string;
+    constructor(data?: PartialMessage<ParticipantMetadataChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ParticipantMetadataChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantMetadataChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantMetadataChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantMetadataChanged;
+    static equals(a: ParticipantMetadataChanged | PlainMessage<ParticipantMetadataChanged> | undefined, b: ParticipantMetadataChanged | PlainMessage<ParticipantMetadataChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ParticipantNameChanged
+ */
+export declare class ParticipantNameChanged extends Message<ParticipantNameChanged> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    constructor(data?: PartialMessage<ParticipantNameChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ParticipantNameChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantNameChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantNameChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantNameChanged;
+    static equals(a: ParticipantNameChanged | PlainMessage<ParticipantNameChanged> | undefined, b: ParticipantNameChanged | PlainMessage<ParticipantNameChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ConnectionQualityChanged
+ */
+export declare class ConnectionQualityChanged extends Message<ConnectionQualityChanged> {
+    /**
+     * @generated from field: string participant_sid = 1;
+     */
+    participantSid: string;
+    /**
+     * @generated from field: livekit.proto.ConnectionQuality quality = 2;
+     */
+    quality: ConnectionQuality;
+    constructor(data?: PartialMessage<ConnectionQualityChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectionQualityChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionQualityChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionQualityChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionQualityChanged;
+    static equals(a: ConnectionQualityChanged | PlainMessage<ConnectionQualityChanged> | undefined, b: ConnectionQualityChanged | PlainMessage<ConnectionQualityChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.DataReceived
+ */
+export declare class DataReceived extends Message<DataReceived> {
+    /**
+     * @generated from field: livekit.proto.OwnedBuffer data = 1;
+     */
+    data?: OwnedBuffer;
+    /**
+     * Can be empty if the data is sent a server SDK
+     *
+     * @generated from field: optional string participant_sid = 2;
+     */
+    participantSid?: string;
+    /**
+     * @generated from field: livekit.proto.DataPacketKind kind = 3;
+     */
+    kind: DataPacketKind;
+    constructor(data?: PartialMessage<DataReceived>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.DataReceived";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataReceived;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataReceived;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataReceived;
+    static equals(a: DataReceived | PlainMessage<DataReceived> | undefined, b: DataReceived | PlainMessage<DataReceived> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.ConnectionStateChanged
+ */
+export declare class ConnectionStateChanged extends Message<ConnectionStateChanged> {
+    /**
+     * @generated from field: livekit.proto.ConnectionState state = 1;
+     */
+    state: ConnectionState;
+    constructor(data?: PartialMessage<ConnectionStateChanged>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.ConnectionStateChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionStateChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionStateChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionStateChanged;
+    static equals(a: ConnectionStateChanged | PlainMessage<ConnectionStateChanged> | undefined, b: ConnectionStateChanged | PlainMessage<ConnectionStateChanged> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.Connected
+ */
+export declare class Connected extends Message<Connected> {
+    constructor(data?: PartialMessage<Connected>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.Connected";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Connected;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Connected;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Connected;
+    static equals(a: Connected | PlainMessage<Connected> | undefined, b: Connected | PlainMessage<Connected> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.Disconnected
+ */
+export declare class Disconnected extends Message<Disconnected> {
+    constructor(data?: PartialMessage<Disconnected>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.Disconnected";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Disconnected;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Disconnected;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Disconnected;
+    static equals(a: Disconnected | PlainMessage<Disconnected> | undefined, b: Disconnected | PlainMessage<Disconnected> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.Reconnecting
+ */
+export declare class Reconnecting extends Message<Reconnecting> {
+    constructor(data?: PartialMessage<Reconnecting>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.Reconnecting";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Reconnecting;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Reconnecting;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Reconnecting;
+    static equals(a: Reconnecting | PlainMessage<Reconnecting> | undefined, b: Reconnecting | PlainMessage<Reconnecting> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.Reconnected
+ */
+export declare class Reconnected extends Message<Reconnected> {
+    constructor(data?: PartialMessage<Reconnected>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.Reconnected";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Reconnected;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Reconnected;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Reconnected;
+    static equals(a: Reconnected | PlainMessage<Reconnected> | undefined, b: Reconnected | PlainMessage<Reconnected> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.RoomEOS
+ */
+export declare class RoomEOS extends Message<RoomEOS> {
+    constructor(data?: PartialMessage<RoomEOS>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "livekit.proto.RoomEOS";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomEOS;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomEOS;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomEOS;
+    static equals(a: RoomEOS | PlainMessage<RoomEOS> | undefined, b: RoomEOS | PlainMessage<RoomEOS> | undefined): boolean;
+}