@livekit/rtc-node 0.12.1 → 0.13.0

package/dist/proto/room_pb.d.ts

@@ -1,61 +1,144 @@
-import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
-import type { E2eeOptions, EncryptionState } from "./e2ee_pb.js";
-import type { FfiOwnedHandle } from "./handle_pb.js";
-import type { OwnedParticipant } from "./participant_pb.js";
-import type { OwnedTrack, OwnedTrackPublication, TrackSource } from "./track_pb.js";
-import type { VideoCodec } from "./video_frame_pb.js";
-import type { RtcStats } from "./stats_pb.js";
-import type { Message } from "@bufbuild/protobuf";
+import { Message, PartialMessage, proto2, FieldList, BinaryReadOptions, JsonValue, JsonReadOptions, PlainMessage } from '@bufbuild/protobuf';
+import { OwnedParticipant, DisconnectReason } from './participant_pb.js';
+import { OwnedTrackPublication, TrackSource, OwnedTrack } from './track_pb.js';
+import { RtcStats } from './stats_pb.js';
+import { VideoCodec } from './video_frame_pb.js';
+import { E2eeOptions, EncryptionState } from './e2ee_pb.js';
+import { FfiOwnedHandle } from './handle_pb.js';
+
 /**
- * Describes the file room.proto.
+ * @generated from enum livekit.proto.IceTransportType
+ */
+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
+ */
+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
+ */
+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 value: QUALITY_LOST = 3;
+     */
+    QUALITY_LOST = 3
+}
+/**
+ * @generated from enum livekit.proto.ConnectionState
+ */
+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 const file_room: GenFile;
+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 type ConnectRequest = Message<"livekit.proto.ConnectRequest"> & {
+declare class ConnectRequest extends Message<ConnectRequest> {
     /**
      * @generated from field: required string url = 1;
      */
-    url: string;
+    url?: string;
     /**
      * @generated from field: required string token = 2;
      */
-    token: string;
+    token?: string;
     /**
      * @generated from field: required livekit.proto.RoomOptions options = 3;
      */
     options?: RoomOptions;
-};
-/**
- * Describes the message livekit.proto.ConnectRequest.
- * Use `create(ConnectRequestSchema)` to create a new message.
- */
-export declare const ConnectRequestSchema: GenMessage<ConnectRequest>;
+    constructor(data?: PartialMessage<ConnectRequest>);
+    static readonly runtime: typeof proto2;
+    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 type ConnectResponse = Message<"livekit.proto.ConnectResponse"> & {
+declare class ConnectResponse extends Message<ConnectResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.ConnectResponse.
- * Use `create(ConnectResponseSchema)` to create a new message.
- */
-export declare const ConnectResponseSchema: GenMessage<ConnectResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<ConnectResponse>);
+    static readonly runtime: typeof proto2;
+    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 type ConnectCallback = Message<"livekit.proto.ConnectCallback"> & {
+declare class ConnectCallback extends Message<ConnectCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from oneof livekit.proto.ConnectCallback.message
      */
@@ -75,16 +158,19 @@ export type ConnectCallback = Message<"livekit.proto.ConnectCallback"> & {
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.ConnectCallback.
- * Use `create(ConnectCallbackSchema)` to create a new message.
- */
-export declare const ConnectCallbackSchema: GenMessage<ConnectCallback>;
+    constructor(data?: PartialMessage<ConnectCallback>);
+    static readonly runtime: typeof proto2;
+    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 type ConnectCallback_ParticipantWithTracks = Message<"livekit.proto.ConnectCallback.ParticipantWithTracks"> & {
+declare class ConnectCallback_ParticipantWithTracks extends Message<ConnectCallback_ParticipantWithTracks> {
     /**
      * @generated from field: required livekit.proto.OwnedParticipant participant = 1;
      */
@@ -96,16 +182,19 @@ export type ConnectCallback_ParticipantWithTracks = Message<"livekit.proto.Conne
      * @generated from field: repeated livekit.proto.OwnedTrackPublication publications = 2;
      */
     publications: OwnedTrackPublication[];
-};
-/**
- * Describes the message livekit.proto.ConnectCallback.ParticipantWithTracks.
- * Use `create(ConnectCallback_ParticipantWithTracksSchema)` to create a new message.
- */
-export declare const ConnectCallback_ParticipantWithTracksSchema: GenMessage<ConnectCallback_ParticipantWithTracks>;
+    constructor(data?: PartialMessage<ConnectCallback_ParticipantWithTracks>);
+    static readonly runtime: typeof proto2;
+    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;
+}
 /**
  * @generated from message livekit.proto.ConnectCallback.Result
  */
-export type ConnectCallback_Result = Message<"livekit.proto.ConnectCallback.Result"> & {
+declare class ConnectCallback_Result extends Message<ConnectCallback_Result> {
     /**
      * @generated from field: required livekit.proto.OwnedRoom room = 1;
      */
@@ -118,102 +207,120 @@ export type ConnectCallback_Result = Message<"livekit.proto.ConnectCallback.Resu
      * @generated from field: repeated livekit.proto.ConnectCallback.ParticipantWithTracks participants = 3;
      */
     participants: ConnectCallback_ParticipantWithTracks[];
-};
-/**
- * Describes the message livekit.proto.ConnectCallback.Result.
- * Use `create(ConnectCallback_ResultSchema)` to create a new message.
- */
-export declare const ConnectCallback_ResultSchema: GenMessage<ConnectCallback_Result>;
+    constructor(data?: PartialMessage<ConnectCallback_Result>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.ConnectCallback.Result";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectCallback_Result;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectCallback_Result;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectCallback_Result;
+    static equals(a: ConnectCallback_Result | PlainMessage<ConnectCallback_Result> | undefined, b: ConnectCallback_Result | PlainMessage<ConnectCallback_Result> | undefined): boolean;
+}
 /**
  * Disconnect from the a room
  *
  * @generated from message livekit.proto.DisconnectRequest
  */
-export type DisconnectRequest = Message<"livekit.proto.DisconnectRequest"> & {
+declare class DisconnectRequest extends Message<DisconnectRequest> {
     /**
      * @generated from field: required uint64 room_handle = 1;
      */
-    roomHandle: bigint;
-};
-/**
- * Describes the message livekit.proto.DisconnectRequest.
- * Use `create(DisconnectRequestSchema)` to create a new message.
- */
-export declare const DisconnectRequestSchema: GenMessage<DisconnectRequest>;
+    roomHandle?: bigint;
+    constructor(data?: PartialMessage<DisconnectRequest>);
+    static readonly runtime: typeof proto2;
+    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 type DisconnectResponse = Message<"livekit.proto.DisconnectResponse"> & {
+declare class DisconnectResponse extends Message<DisconnectResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.DisconnectResponse.
- * Use `create(DisconnectResponseSchema)` to create a new message.
- */
-export declare const DisconnectResponseSchema: GenMessage<DisconnectResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<DisconnectResponse>);
+    static readonly runtime: typeof proto2;
+    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 type DisconnectCallback = Message<"livekit.proto.DisconnectCallback"> & {
+declare class DisconnectCallback extends Message<DisconnectCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.DisconnectCallback.
- * Use `create(DisconnectCallbackSchema)` to create a new message.
- */
-export declare const DisconnectCallbackSchema: GenMessage<DisconnectCallback>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<DisconnectCallback>);
+    static readonly runtime: typeof proto2;
+    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 type PublishTrackRequest = Message<"livekit.proto.PublishTrackRequest"> & {
+declare class PublishTrackRequest extends Message<PublishTrackRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required uint64 track_handle = 2;
      */
-    trackHandle: bigint;
+    trackHandle?: bigint;
     /**
      * @generated from field: required livekit.proto.TrackPublishOptions options = 3;
      */
     options?: TrackPublishOptions;
-};
-/**
- * Describes the message livekit.proto.PublishTrackRequest.
- * Use `create(PublishTrackRequestSchema)` to create a new message.
- */
-export declare const PublishTrackRequestSchema: GenMessage<PublishTrackRequest>;
+    constructor(data?: PartialMessage<PublishTrackRequest>);
+    static readonly runtime: typeof proto2;
+    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 type PublishTrackResponse = Message<"livekit.proto.PublishTrackResponse"> & {
+declare class PublishTrackResponse extends Message<PublishTrackResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.PublishTrackResponse.
- * Use `create(PublishTrackResponseSchema)` to create a new message.
- */
-export declare const PublishTrackResponseSchema: GenMessage<PublishTrackResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<PublishTrackResponse>);
+    static readonly runtime: typeof proto2;
+    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 type PublishTrackCallback = Message<"livekit.proto.PublishTrackCallback"> & {
+declare class PublishTrackCallback extends Message<PublishTrackCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from oneof livekit.proto.PublishTrackCallback.message
      */
@@ -233,90 +340,102 @@ export type PublishTrackCallback = Message<"livekit.proto.PublishTrackCallback">
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.PublishTrackCallback.
- * Use `create(PublishTrackCallbackSchema)` to create a new message.
- */
-export declare const PublishTrackCallbackSchema: GenMessage<PublishTrackCallback>;
+    constructor(data?: PartialMessage<PublishTrackCallback>);
+    static readonly runtime: typeof proto2;
+    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 type UnpublishTrackRequest = Message<"livekit.proto.UnpublishTrackRequest"> & {
+declare class UnpublishTrackRequest extends Message<UnpublishTrackRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
+    trackSid?: string;
     /**
      * @generated from field: required bool stop_on_unpublish = 3;
      */
-    stopOnUnpublish: boolean;
-};
-/**
- * Describes the message livekit.proto.UnpublishTrackRequest.
- * Use `create(UnpublishTrackRequestSchema)` to create a new message.
- */
-export declare const UnpublishTrackRequestSchema: GenMessage<UnpublishTrackRequest>;
+    stopOnUnpublish?: boolean;
+    constructor(data?: PartialMessage<UnpublishTrackRequest>);
+    static readonly runtime: typeof proto2;
+    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 type UnpublishTrackResponse = Message<"livekit.proto.UnpublishTrackResponse"> & {
+declare class UnpublishTrackResponse extends Message<UnpublishTrackResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.UnpublishTrackResponse.
- * Use `create(UnpublishTrackResponseSchema)` to create a new message.
- */
-export declare const UnpublishTrackResponseSchema: GenMessage<UnpublishTrackResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<UnpublishTrackResponse>);
+    static readonly runtime: typeof proto2;
+    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 type UnpublishTrackCallback = Message<"livekit.proto.UnpublishTrackCallback"> & {
+declare class UnpublishTrackCallback extends Message<UnpublishTrackCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.UnpublishTrackCallback.
- * Use `create(UnpublishTrackCallbackSchema)` to create a new message.
- */
-export declare const UnpublishTrackCallbackSchema: GenMessage<UnpublishTrackCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<UnpublishTrackCallback>);
+    static readonly runtime: typeof proto2;
+    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 type PublishDataRequest = Message<"livekit.proto.PublishDataRequest"> & {
+declare class PublishDataRequest extends Message<PublishDataRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required uint64 data_ptr = 2;
      */
-    dataPtr: bigint;
+    dataPtr?: bigint;
     /**
      * @generated from field: required uint64 data_len = 3;
      */
-    dataLen: bigint;
+    dataLen?: bigint;
     /**
      * @generated from field: required bool reliable = 4;
      */
-    reliable: boolean;
+    reliable?: boolean;
     /**
      * @generated from field: repeated string destination_sids = 5 [deprecated = true];
      * @deprecated
@@ -325,233 +444,269 @@ export type PublishDataRequest = Message<"livekit.proto.PublishDataRequest"> & {
     /**
      * @generated from field: optional string topic = 6;
      */
-    topic: string;
+    topic?: string;
     /**
      * @generated from field: repeated string destination_identities = 7;
      */
     destinationIdentities: string[];
-};
-/**
- * Describes the message livekit.proto.PublishDataRequest.
- * Use `create(PublishDataRequestSchema)` to create a new message.
- */
-export declare const PublishDataRequestSchema: GenMessage<PublishDataRequest>;
+    constructor(data?: PartialMessage<PublishDataRequest>);
+    static readonly runtime: typeof proto2;
+    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 type PublishDataResponse = Message<"livekit.proto.PublishDataResponse"> & {
+declare class PublishDataResponse extends Message<PublishDataResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.PublishDataResponse.
- * Use `create(PublishDataResponseSchema)` to create a new message.
- */
-export declare const PublishDataResponseSchema: GenMessage<PublishDataResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<PublishDataResponse>);
+    static readonly runtime: typeof proto2;
+    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 type PublishDataCallback = Message<"livekit.proto.PublishDataCallback"> & {
+declare class PublishDataCallback extends Message<PublishDataCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.PublishDataCallback.
- * Use `create(PublishDataCallbackSchema)` to create a new message.
- */
-export declare const PublishDataCallbackSchema: GenMessage<PublishDataCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<PublishDataCallback>);
+    static readonly runtime: typeof proto2;
+    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;
+}
 /**
  * Publish transcription messages to room
  *
  * @generated from message livekit.proto.PublishTranscriptionRequest
  */
-export type PublishTranscriptionRequest = Message<"livekit.proto.PublishTranscriptionRequest"> & {
+declare class PublishTranscriptionRequest extends Message<PublishTranscriptionRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string participant_identity = 2;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string track_id = 3;
      */
-    trackId: string;
+    trackId?: string;
     /**
      * @generated from field: repeated livekit.proto.TranscriptionSegment segments = 4;
      */
     segments: TranscriptionSegment[];
-};
-/**
- * Describes the message livekit.proto.PublishTranscriptionRequest.
- * Use `create(PublishTranscriptionRequestSchema)` to create a new message.
- */
-export declare const PublishTranscriptionRequestSchema: GenMessage<PublishTranscriptionRequest>;
+    constructor(data?: PartialMessage<PublishTranscriptionRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishTranscriptionRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTranscriptionRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTranscriptionRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTranscriptionRequest;
+    static equals(a: PublishTranscriptionRequest | PlainMessage<PublishTranscriptionRequest> | undefined, b: PublishTranscriptionRequest | PlainMessage<PublishTranscriptionRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.PublishTranscriptionResponse
  */
-export type PublishTranscriptionResponse = Message<"livekit.proto.PublishTranscriptionResponse"> & {
+declare class PublishTranscriptionResponse extends Message<PublishTranscriptionResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.PublishTranscriptionResponse.
- * Use `create(PublishTranscriptionResponseSchema)` to create a new message.
- */
-export declare const PublishTranscriptionResponseSchema: GenMessage<PublishTranscriptionResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<PublishTranscriptionResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishTranscriptionResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTranscriptionResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTranscriptionResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTranscriptionResponse;
+    static equals(a: PublishTranscriptionResponse | PlainMessage<PublishTranscriptionResponse> | undefined, b: PublishTranscriptionResponse | PlainMessage<PublishTranscriptionResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.PublishTranscriptionCallback
  */
-export type PublishTranscriptionCallback = Message<"livekit.proto.PublishTranscriptionCallback"> & {
+declare class PublishTranscriptionCallback extends Message<PublishTranscriptionCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.PublishTranscriptionCallback.
- * Use `create(PublishTranscriptionCallbackSchema)` to create a new message.
- */
-export declare const PublishTranscriptionCallbackSchema: GenMessage<PublishTranscriptionCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<PublishTranscriptionCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishTranscriptionCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishTranscriptionCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishTranscriptionCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishTranscriptionCallback;
+    static equals(a: PublishTranscriptionCallback | PlainMessage<PublishTranscriptionCallback> | undefined, b: PublishTranscriptionCallback | PlainMessage<PublishTranscriptionCallback> | undefined): boolean;
+}
 /**
  * Publish Sip DTMF messages to other participants
  *
  * @generated from message livekit.proto.PublishSipDtmfRequest
  */
-export type PublishSipDtmfRequest = Message<"livekit.proto.PublishSipDtmfRequest"> & {
+declare class PublishSipDtmfRequest extends Message<PublishSipDtmfRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required uint32 code = 2;
      */
-    code: number;
+    code?: number;
     /**
      * @generated from field: required string digit = 3;
      */
-    digit: string;
+    digit?: string;
     /**
      * @generated from field: repeated string destination_identities = 4;
      */
     destinationIdentities: string[];
-};
-/**
- * Describes the message livekit.proto.PublishSipDtmfRequest.
- * Use `create(PublishSipDtmfRequestSchema)` to create a new message.
- */
-export declare const PublishSipDtmfRequestSchema: GenMessage<PublishSipDtmfRequest>;
+    constructor(data?: PartialMessage<PublishSipDtmfRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishSipDtmfRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishSipDtmfRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishSipDtmfRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishSipDtmfRequest;
+    static equals(a: PublishSipDtmfRequest | PlainMessage<PublishSipDtmfRequest> | undefined, b: PublishSipDtmfRequest | PlainMessage<PublishSipDtmfRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.PublishSipDtmfResponse
  */
-export type PublishSipDtmfResponse = Message<"livekit.proto.PublishSipDtmfResponse"> & {
+declare class PublishSipDtmfResponse extends Message<PublishSipDtmfResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.PublishSipDtmfResponse.
- * Use `create(PublishSipDtmfResponseSchema)` to create a new message.
- */
-export declare const PublishSipDtmfResponseSchema: GenMessage<PublishSipDtmfResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<PublishSipDtmfResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishSipDtmfResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishSipDtmfResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishSipDtmfResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishSipDtmfResponse;
+    static equals(a: PublishSipDtmfResponse | PlainMessage<PublishSipDtmfResponse> | undefined, b: PublishSipDtmfResponse | PlainMessage<PublishSipDtmfResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.PublishSipDtmfCallback
  */
-export type PublishSipDtmfCallback = Message<"livekit.proto.PublishSipDtmfCallback"> & {
+declare class PublishSipDtmfCallback extends Message<PublishSipDtmfCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.PublishSipDtmfCallback.
- * Use `create(PublishSipDtmfCallbackSchema)` to create a new message.
- */
-export declare const PublishSipDtmfCallbackSchema: GenMessage<PublishSipDtmfCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<PublishSipDtmfCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.PublishSipDtmfCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublishSipDtmfCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublishSipDtmfCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublishSipDtmfCallback;
+    static equals(a: PublishSipDtmfCallback | PlainMessage<PublishSipDtmfCallback> | undefined, b: PublishSipDtmfCallback | PlainMessage<PublishSipDtmfCallback> | undefined): boolean;
+}
 /**
  * Change the local participant's metadata
  *
  * @generated from message livekit.proto.SetLocalMetadataRequest
  */
-export type SetLocalMetadataRequest = Message<"livekit.proto.SetLocalMetadataRequest"> & {
+declare class SetLocalMetadataRequest extends Message<SetLocalMetadataRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string metadata = 2;
      */
-    metadata: string;
-};
-/**
- * Describes the message livekit.proto.SetLocalMetadataRequest.
- * Use `create(SetLocalMetadataRequestSchema)` to create a new message.
- */
-export declare const SetLocalMetadataRequestSchema: GenMessage<SetLocalMetadataRequest>;
+    metadata?: string;
+    constructor(data?: PartialMessage<SetLocalMetadataRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalMetadataRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalMetadataRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalMetadataRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalMetadataRequest;
+    static equals(a: SetLocalMetadataRequest | PlainMessage<SetLocalMetadataRequest> | undefined, b: SetLocalMetadataRequest | PlainMessage<SetLocalMetadataRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalMetadataResponse
  */
-export type SetLocalMetadataResponse = Message<"livekit.proto.SetLocalMetadataResponse"> & {
+declare class SetLocalMetadataResponse extends Message<SetLocalMetadataResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.SetLocalMetadataResponse.
- * Use `create(SetLocalMetadataResponseSchema)` to create a new message.
- */
-export declare const SetLocalMetadataResponseSchema: GenMessage<SetLocalMetadataResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<SetLocalMetadataResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalMetadataResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalMetadataResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalMetadataResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalMetadataResponse;
+    static equals(a: SetLocalMetadataResponse | PlainMessage<SetLocalMetadataResponse> | undefined, b: SetLocalMetadataResponse | PlainMessage<SetLocalMetadataResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalMetadataCallback
  */
-export type SetLocalMetadataCallback = Message<"livekit.proto.SetLocalMetadataCallback"> & {
+declare class SetLocalMetadataCallback extends Message<SetLocalMetadataCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.SetLocalMetadataCallback.
- * Use `create(SetLocalMetadataCallbackSchema)` to create a new message.
- */
-export declare const SetLocalMetadataCallbackSchema: GenMessage<SetLocalMetadataCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<SetLocalMetadataCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalMetadataCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalMetadataCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalMetadataCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalMetadataCallback;
+    static equals(a: SetLocalMetadataCallback | PlainMessage<SetLocalMetadataCallback> | undefined, b: SetLocalMetadataCallback | PlainMessage<SetLocalMetadataCallback> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SendChatMessageRequest
  */
-export type SendChatMessageRequest = Message<"livekit.proto.SendChatMessageRequest"> & {
+declare class SendChatMessageRequest extends Message<SendChatMessageRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string message = 2;
      */
-    message: string;
+    message?: string;
     /**
      * @generated from field: repeated string destination_identities = 3;
      */
@@ -559,25 +714,28 @@ export type SendChatMessageRequest = Message<"livekit.proto.SendChatMessageReque
     /**
      * @generated from field: optional string sender_identity = 4;
      */
-    senderIdentity: string;
-};
-/**
- * Describes the message livekit.proto.SendChatMessageRequest.
- * Use `create(SendChatMessageRequestSchema)` to create a new message.
- */
-export declare const SendChatMessageRequestSchema: GenMessage<SendChatMessageRequest>;
+    senderIdentity?: string;
+    constructor(data?: PartialMessage<SendChatMessageRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SendChatMessageRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendChatMessageRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendChatMessageRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendChatMessageRequest;
+    static equals(a: SendChatMessageRequest | PlainMessage<SendChatMessageRequest> | undefined, b: SendChatMessageRequest | PlainMessage<SendChatMessageRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.EditChatMessageRequest
  */
-export type EditChatMessageRequest = Message<"livekit.proto.EditChatMessageRequest"> & {
+declare class EditChatMessageRequest extends Message<EditChatMessageRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string edit_text = 2;
      */
-    editText: string;
+    editText?: string;
     /**
      * @generated from field: required livekit.proto.ChatMessage original_message = 3;
      */
@@ -589,35 +747,41 @@ export type EditChatMessageRequest = Message<"livekit.proto.EditChatMessageReque
     /**
      * @generated from field: optional string sender_identity = 5;
      */
-    senderIdentity: string;
-};
-/**
- * Describes the message livekit.proto.EditChatMessageRequest.
- * Use `create(EditChatMessageRequestSchema)` to create a new message.
- */
-export declare const EditChatMessageRequestSchema: GenMessage<EditChatMessageRequest>;
+    senderIdentity?: string;
+    constructor(data?: PartialMessage<EditChatMessageRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.EditChatMessageRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EditChatMessageRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EditChatMessageRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EditChatMessageRequest;
+    static equals(a: EditChatMessageRequest | PlainMessage<EditChatMessageRequest> | undefined, b: EditChatMessageRequest | PlainMessage<EditChatMessageRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SendChatMessageResponse
  */
-export type SendChatMessageResponse = Message<"livekit.proto.SendChatMessageResponse"> & {
+declare class SendChatMessageResponse extends Message<SendChatMessageResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.SendChatMessageResponse.
- * Use `create(SendChatMessageResponseSchema)` to create a new message.
- */
-export declare const SendChatMessageResponseSchema: GenMessage<SendChatMessageResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<SendChatMessageResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SendChatMessageResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendChatMessageResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendChatMessageResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendChatMessageResponse;
+    static equals(a: SendChatMessageResponse | PlainMessage<SendChatMessageResponse> | undefined, b: SendChatMessageResponse | PlainMessage<SendChatMessageResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SendChatMessageCallback
  */
-export type SendChatMessageCallback = Message<"livekit.proto.SendChatMessageCallback"> & {
+declare class SendChatMessageCallback extends Message<SendChatMessageCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from oneof livekit.proto.SendChatMessageCallback.message
      */
@@ -637,199 +801,236 @@ export type SendChatMessageCallback = Message<"livekit.proto.SendChatMessageCall
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.SendChatMessageCallback.
- * Use `create(SendChatMessageCallbackSchema)` to create a new message.
- */
-export declare const SendChatMessageCallbackSchema: GenMessage<SendChatMessageCallback>;
+    constructor(data?: PartialMessage<SendChatMessageCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SendChatMessageCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendChatMessageCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendChatMessageCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendChatMessageCallback;
+    static equals(a: SendChatMessageCallback | PlainMessage<SendChatMessageCallback> | undefined, b: SendChatMessageCallback | PlainMessage<SendChatMessageCallback> | undefined): boolean;
+}
 /**
  * Change the local participant's attributes
  *
  * @generated from message livekit.proto.SetLocalAttributesRequest
  */
-export type SetLocalAttributesRequest = Message<"livekit.proto.SetLocalAttributesRequest"> & {
+declare class SetLocalAttributesRequest extends Message<SetLocalAttributesRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: repeated livekit.proto.AttributesEntry attributes = 2;
      */
     attributes: AttributesEntry[];
-};
-/**
- * Describes the message livekit.proto.SetLocalAttributesRequest.
- * Use `create(SetLocalAttributesRequestSchema)` to create a new message.
- */
-export declare const SetLocalAttributesRequestSchema: GenMessage<SetLocalAttributesRequest>;
+    constructor(data?: PartialMessage<SetLocalAttributesRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalAttributesRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalAttributesRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalAttributesRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalAttributesRequest;
+    static equals(a: SetLocalAttributesRequest | PlainMessage<SetLocalAttributesRequest> | undefined, b: SetLocalAttributesRequest | PlainMessage<SetLocalAttributesRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.AttributesEntry
  */
-export type AttributesEntry = Message<"livekit.proto.AttributesEntry"> & {
+declare class AttributesEntry extends Message<AttributesEntry> {
     /**
      * @generated from field: required string key = 1;
      */
-    key: string;
+    key?: string;
     /**
      * @generated from field: required string value = 2;
      */
-    value: string;
-};
-/**
- * Describes the message livekit.proto.AttributesEntry.
- * Use `create(AttributesEntrySchema)` to create a new message.
- */
-export declare const AttributesEntrySchema: GenMessage<AttributesEntry>;
+    value?: string;
+    constructor(data?: PartialMessage<AttributesEntry>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.AttributesEntry";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AttributesEntry;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AttributesEntry;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AttributesEntry;
+    static equals(a: AttributesEntry | PlainMessage<AttributesEntry> | undefined, b: AttributesEntry | PlainMessage<AttributesEntry> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalAttributesResponse
  */
-export type SetLocalAttributesResponse = Message<"livekit.proto.SetLocalAttributesResponse"> & {
+declare class SetLocalAttributesResponse extends Message<SetLocalAttributesResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.SetLocalAttributesResponse.
- * Use `create(SetLocalAttributesResponseSchema)` to create a new message.
- */
-export declare const SetLocalAttributesResponseSchema: GenMessage<SetLocalAttributesResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<SetLocalAttributesResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalAttributesResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalAttributesResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalAttributesResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalAttributesResponse;
+    static equals(a: SetLocalAttributesResponse | PlainMessage<SetLocalAttributesResponse> | undefined, b: SetLocalAttributesResponse | PlainMessage<SetLocalAttributesResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalAttributesCallback
  */
-export type SetLocalAttributesCallback = Message<"livekit.proto.SetLocalAttributesCallback"> & {
+declare class SetLocalAttributesCallback extends Message<SetLocalAttributesCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.SetLocalAttributesCallback.
- * Use `create(SetLocalAttributesCallbackSchema)` to create a new message.
- */
-export declare const SetLocalAttributesCallbackSchema: GenMessage<SetLocalAttributesCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<SetLocalAttributesCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalAttributesCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalAttributesCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalAttributesCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalAttributesCallback;
+    static equals(a: SetLocalAttributesCallback | PlainMessage<SetLocalAttributesCallback> | undefined, b: SetLocalAttributesCallback | PlainMessage<SetLocalAttributesCallback> | undefined): boolean;
+}
 /**
  * Change the local participant's name
  *
  * @generated from message livekit.proto.SetLocalNameRequest
  */
-export type SetLocalNameRequest = Message<"livekit.proto.SetLocalNameRequest"> & {
+declare class SetLocalNameRequest extends Message<SetLocalNameRequest> {
     /**
      * @generated from field: required uint64 local_participant_handle = 1;
      */
-    localParticipantHandle: bigint;
+    localParticipantHandle?: bigint;
     /**
      * @generated from field: required string name = 2;
      */
-    name: string;
-};
-/**
- * Describes the message livekit.proto.SetLocalNameRequest.
- * Use `create(SetLocalNameRequestSchema)` to create a new message.
- */
-export declare const SetLocalNameRequestSchema: GenMessage<SetLocalNameRequest>;
+    name?: string;
+    constructor(data?: PartialMessage<SetLocalNameRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalNameRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalNameRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalNameRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalNameRequest;
+    static equals(a: SetLocalNameRequest | PlainMessage<SetLocalNameRequest> | undefined, b: SetLocalNameRequest | PlainMessage<SetLocalNameRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalNameResponse
  */
-export type SetLocalNameResponse = Message<"livekit.proto.SetLocalNameResponse"> & {
+declare class SetLocalNameResponse extends Message<SetLocalNameResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.SetLocalNameResponse.
- * Use `create(SetLocalNameResponseSchema)` to create a new message.
- */
-export declare const SetLocalNameResponseSchema: GenMessage<SetLocalNameResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<SetLocalNameResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalNameResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalNameResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalNameResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalNameResponse;
+    static equals(a: SetLocalNameResponse | PlainMessage<SetLocalNameResponse> | undefined, b: SetLocalNameResponse | PlainMessage<SetLocalNameResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SetLocalNameCallback
  */
-export type SetLocalNameCallback = Message<"livekit.proto.SetLocalNameCallback"> & {
+declare class SetLocalNameCallback extends Message<SetLocalNameCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from field: optional string error = 2;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.SetLocalNameCallback.
- * Use `create(SetLocalNameCallbackSchema)` to create a new message.
- */
-export declare const SetLocalNameCallbackSchema: GenMessage<SetLocalNameCallback>;
+    error?: string;
+    constructor(data?: PartialMessage<SetLocalNameCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SetLocalNameCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetLocalNameCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetLocalNameCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetLocalNameCallback;
+    static equals(a: SetLocalNameCallback | PlainMessage<SetLocalNameCallback> | undefined, b: SetLocalNameCallback | PlainMessage<SetLocalNameCallback> | undefined): boolean;
+}
 /**
  * Change the "desire" to subs2ribe to a track
  *
  * @generated from message livekit.proto.SetSubscribedRequest
  */
-export type SetSubscribedRequest = Message<"livekit.proto.SetSubscribedRequest"> & {
+declare class SetSubscribedRequest extends Message<SetSubscribedRequest> {
     /**
      * @generated from field: required bool subscribe = 1;
      */
-    subscribe: boolean;
+    subscribe?: boolean;
     /**
      * @generated from field: required uint64 publication_handle = 2;
      */
-    publicationHandle: bigint;
-};
-/**
- * Describes the message livekit.proto.SetSubscribedRequest.
- * Use `create(SetSubscribedRequestSchema)` to create a new message.
- */
-export declare const SetSubscribedRequestSchema: GenMessage<SetSubscribedRequest>;
+    publicationHandle?: bigint;
+    constructor(data?: PartialMessage<SetSubscribedRequest>);
+    static readonly runtime: typeof proto2;
+    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 type SetSubscribedResponse = Message<"livekit.proto.SetSubscribedResponse"> & {};
-/**
- * Describes the message livekit.proto.SetSubscribedResponse.
- * Use `create(SetSubscribedResponseSchema)` to create a new message.
- */
-export declare const SetSubscribedResponseSchema: GenMessage<SetSubscribedResponse>;
+declare class SetSubscribedResponse extends Message<SetSubscribedResponse> {
+    constructor(data?: PartialMessage<SetSubscribedResponse>);
+    static readonly runtime: typeof proto2;
+    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.GetSessionStatsRequest
  */
-export type GetSessionStatsRequest = Message<"livekit.proto.GetSessionStatsRequest"> & {
+declare class GetSessionStatsRequest extends Message<GetSessionStatsRequest> {
     /**
      * @generated from field: required uint64 room_handle = 1;
      */
-    roomHandle: bigint;
-};
-/**
- * Describes the message livekit.proto.GetSessionStatsRequest.
- * Use `create(GetSessionStatsRequestSchema)` to create a new message.
- */
-export declare const GetSessionStatsRequestSchema: GenMessage<GetSessionStatsRequest>;
+    roomHandle?: bigint;
+    constructor(data?: PartialMessage<GetSessionStatsRequest>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.GetSessionStatsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionStatsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionStatsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionStatsRequest;
+    static equals(a: GetSessionStatsRequest | PlainMessage<GetSessionStatsRequest> | undefined, b: GetSessionStatsRequest | PlainMessage<GetSessionStatsRequest> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.GetSessionStatsResponse
  */
-export type GetSessionStatsResponse = Message<"livekit.proto.GetSessionStatsResponse"> & {
+declare class GetSessionStatsResponse extends Message<GetSessionStatsResponse> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
-};
-/**
- * Describes the message livekit.proto.GetSessionStatsResponse.
- * Use `create(GetSessionStatsResponseSchema)` to create a new message.
- */
-export declare const GetSessionStatsResponseSchema: GenMessage<GetSessionStatsResponse>;
+    asyncId?: bigint;
+    constructor(data?: PartialMessage<GetSessionStatsResponse>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.GetSessionStatsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionStatsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionStatsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionStatsResponse;
+    static equals(a: GetSessionStatsResponse | PlainMessage<GetSessionStatsResponse> | undefined, b: GetSessionStatsResponse | PlainMessage<GetSessionStatsResponse> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.GetSessionStatsCallback
  */
-export type GetSessionStatsCallback = Message<"livekit.proto.GetSessionStatsCallback"> & {
+declare class GetSessionStatsCallback extends Message<GetSessionStatsCallback> {
     /**
      * @generated from field: required uint64 async_id = 1;
      */
-    asyncId: bigint;
+    asyncId?: bigint;
     /**
      * @generated from oneof livekit.proto.GetSessionStatsCallback.message
      */
@@ -849,16 +1050,19 @@ export type GetSessionStatsCallback = Message<"livekit.proto.GetSessionStatsCall
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.GetSessionStatsCallback.
- * Use `create(GetSessionStatsCallbackSchema)` to create a new message.
- */
-export declare const GetSessionStatsCallbackSchema: GenMessage<GetSessionStatsCallback>;
+    constructor(data?: PartialMessage<GetSessionStatsCallback>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.GetSessionStatsCallback";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionStatsCallback;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionStatsCallback;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionStatsCallback;
+    static equals(a: GetSessionStatsCallback | PlainMessage<GetSessionStatsCallback> | undefined, b: GetSessionStatsCallback | PlainMessage<GetSessionStatsCallback> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.GetSessionStatsCallback.Result
  */
-export type GetSessionStatsCallback_Result = Message<"livekit.proto.GetSessionStatsCallback.Result"> & {
+declare class GetSessionStatsCallback_Result extends Message<GetSessionStatsCallback_Result> {
     /**
      * @generated from field: repeated livekit.proto.RtcStats publisher_stats = 1;
      */
@@ -867,48 +1071,57 @@ export type GetSessionStatsCallback_Result = Message<"livekit.proto.GetSessionSt
      * @generated from field: repeated livekit.proto.RtcStats subscriber_stats = 2;
      */
     subscriberStats: RtcStats[];
-};
-/**
- * Describes the message livekit.proto.GetSessionStatsCallback.Result.
- * Use `create(GetSessionStatsCallback_ResultSchema)` to create a new message.
- */
-export declare const GetSessionStatsCallback_ResultSchema: GenMessage<GetSessionStatsCallback_Result>;
+    constructor(data?: PartialMessage<GetSessionStatsCallback_Result>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.GetSessionStatsCallback.Result";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionStatsCallback_Result;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionStatsCallback_Result;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionStatsCallback_Result;
+    static equals(a: GetSessionStatsCallback_Result | PlainMessage<GetSessionStatsCallback_Result> | undefined, b: GetSessionStatsCallback_Result | PlainMessage<GetSessionStatsCallback_Result> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.VideoEncoding
  */
-export type VideoEncoding = Message<"livekit.proto.VideoEncoding"> & {
+declare class VideoEncoding extends Message<VideoEncoding> {
     /**
      * @generated from field: required uint64 max_bitrate = 1;
      */
-    maxBitrate: bigint;
+    maxBitrate?: bigint;
     /**
      * @generated from field: required double max_framerate = 2;
      */
-    maxFramerate: number;
-};
-/**
- * Describes the message livekit.proto.VideoEncoding.
- * Use `create(VideoEncodingSchema)` to create a new message.
- */
-export declare const VideoEncodingSchema: GenMessage<VideoEncoding>;
+    maxFramerate?: number;
+    constructor(data?: PartialMessage<VideoEncoding>);
+    static readonly runtime: typeof proto2;
+    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 type AudioEncoding = Message<"livekit.proto.AudioEncoding"> & {
+declare class AudioEncoding extends Message<AudioEncoding> {
     /**
      * @generated from field: required uint64 max_bitrate = 1;
      */
-    maxBitrate: bigint;
-};
-/**
- * Describes the message livekit.proto.AudioEncoding.
- * Use `create(AudioEncodingSchema)` to create a new message.
- */
-export declare const AudioEncodingSchema: GenMessage<AudioEncoding>;
+    maxBitrate?: bigint;
+    constructor(data?: PartialMessage<AudioEncoding>);
+    static readonly runtime: typeof proto2;
+    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 type TrackPublishOptions = Message<"livekit.proto.TrackPublishOptions"> & {
+declare class TrackPublishOptions extends Message<TrackPublishOptions> {
     /**
      * encodings are optional
      *
@@ -922,37 +1135,40 @@ export type TrackPublishOptions = Message<"livekit.proto.TrackPublishOptions"> &
     /**
      * @generated from field: optional livekit.proto.VideoCodec video_codec = 3;
      */
-    videoCodec: VideoCodec;
+    videoCodec?: VideoCodec;
     /**
      * @generated from field: optional bool dtx = 4;
      */
-    dtx: boolean;
+    dtx?: boolean;
     /**
      * @generated from field: optional bool red = 5;
      */
-    red: boolean;
+    red?: boolean;
     /**
      * @generated from field: optional bool simulcast = 6;
      */
-    simulcast: boolean;
+    simulcast?: boolean;
     /**
      * @generated from field: optional livekit.proto.TrackSource source = 7;
      */
-    source: TrackSource;
+    source?: TrackSource;
     /**
      * @generated from field: optional string stream = 8;
      */
-    stream: string;
-};
-/**
- * Describes the message livekit.proto.TrackPublishOptions.
- * Use `create(TrackPublishOptionsSchema)` to create a new message.
- */
-export declare const TrackPublishOptionsSchema: GenMessage<TrackPublishOptions>;
+    stream?: string;
+    constructor(data?: PartialMessage<TrackPublishOptions>);
+    static readonly runtime: typeof proto2;
+    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 type IceServer = Message<"livekit.proto.IceServer"> & {
+declare class IceServer extends Message<IceServer> {
     /**
      * @generated from field: repeated string urls = 1;
      */
@@ -960,57 +1176,63 @@ export type IceServer = Message<"livekit.proto.IceServer"> & {
     /**
      * @generated from field: optional string username = 2;
      */
-    username: string;
+    username?: string;
     /**
      * @generated from field: optional string password = 3;
      */
-    password: string;
-};
-/**
- * Describes the message livekit.proto.IceServer.
- * Use `create(IceServerSchema)` to create a new message.
- */
-export declare const IceServerSchema: GenMessage<IceServer>;
+    password?: string;
+    constructor(data?: PartialMessage<IceServer>);
+    static readonly runtime: typeof proto2;
+    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 type RtcConfig = Message<"livekit.proto.RtcConfig"> & {
+declare class RtcConfig extends Message<RtcConfig> {
     /**
      * @generated from field: optional livekit.proto.IceTransportType ice_transport_type = 1;
      */
-    iceTransportType: IceTransportType;
+    iceTransportType?: IceTransportType;
     /**
      * @generated from field: optional livekit.proto.ContinualGatheringPolicy continual_gathering_policy = 2;
      */
-    continualGatheringPolicy: ContinualGatheringPolicy;
+    continualGatheringPolicy?: ContinualGatheringPolicy;
     /**
      * empty fallback to default
      *
      * @generated from field: repeated livekit.proto.IceServer ice_servers = 3;
      */
     iceServers: IceServer[];
-};
-/**
- * Describes the message livekit.proto.RtcConfig.
- * Use `create(RtcConfigSchema)` to create a new message.
- */
-export declare const RtcConfigSchema: GenMessage<RtcConfig>;
+    constructor(data?: PartialMessage<RtcConfig>);
+    static readonly runtime: typeof proto2;
+    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 type RoomOptions = Message<"livekit.proto.RoomOptions"> & {
+declare class RoomOptions extends Message<RoomOptions> {
     /**
      * @generated from field: optional bool auto_subscribe = 1;
      */
-    autoSubscribe: boolean;
+    autoSubscribe?: boolean;
     /**
      * @generated from field: optional bool adaptive_stream = 2;
      */
-    adaptiveStream: boolean;
+    adaptiveStream?: boolean;
     /**
      * @generated from field: optional bool dynacast = 3;
      */
-    dynacast: boolean;
+    dynacast?: boolean;
     /**
      * @generated from field: optional livekit.proto.E2eeOptions e2ee = 4;
      */
@@ -1024,69 +1246,78 @@ export type RoomOptions = Message<"livekit.proto.RoomOptions"> & {
     /**
      * @generated from field: optional uint32 join_retries = 6;
      */
-    joinRetries: number;
-};
-/**
- * Describes the message livekit.proto.RoomOptions.
- * Use `create(RoomOptionsSchema)` to create a new message.
- */
-export declare const RoomOptionsSchema: GenMessage<RoomOptions>;
+    joinRetries?: number;
+    constructor(data?: PartialMessage<RoomOptions>);
+    static readonly runtime: typeof proto2;
+    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.TranscriptionSegment
  */
-export type TranscriptionSegment = Message<"livekit.proto.TranscriptionSegment"> & {
+declare class TranscriptionSegment extends Message<TranscriptionSegment> {
     /**
      * @generated from field: required string id = 1;
      */
-    id: string;
+    id?: string;
     /**
      * @generated from field: required string text = 2;
      */
-    text: string;
+    text?: string;
     /**
      * @generated from field: required uint64 start_time = 3;
      */
-    startTime: bigint;
+    startTime?: bigint;
     /**
      * @generated from field: required uint64 end_time = 4;
      */
-    endTime: bigint;
+    endTime?: bigint;
     /**
      * @generated from field: required bool final = 5;
      */
-    final: boolean;
+    final?: boolean;
     /**
      * @generated from field: required string language = 6;
      */
-    language: string;
-};
-/**
- * Describes the message livekit.proto.TranscriptionSegment.
- * Use `create(TranscriptionSegmentSchema)` to create a new message.
- */
-export declare const TranscriptionSegmentSchema: GenMessage<TranscriptionSegment>;
+    language?: string;
+    constructor(data?: PartialMessage<TranscriptionSegment>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.TranscriptionSegment";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TranscriptionSegment;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TranscriptionSegment;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TranscriptionSegment;
+    static equals(a: TranscriptionSegment | PlainMessage<TranscriptionSegment> | undefined, b: TranscriptionSegment | PlainMessage<TranscriptionSegment> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.BufferInfo
  */
-export type BufferInfo = Message<"livekit.proto.BufferInfo"> & {
+declare class BufferInfo extends Message<BufferInfo> {
     /**
      * @generated from field: required uint64 data_ptr = 1;
      */
-    dataPtr: bigint;
+    dataPtr?: bigint;
     /**
      * @generated from field: required uint64 data_len = 2;
      */
-    dataLen: bigint;
-};
-/**
- * Describes the message livekit.proto.BufferInfo.
- * Use `create(BufferInfoSchema)` to create a new message.
- */
-export declare const BufferInfoSchema: GenMessage<BufferInfo>;
+    dataLen?: bigint;
+    constructor(data?: PartialMessage<BufferInfo>);
+    static readonly runtime: typeof proto2;
+    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 type OwnedBuffer = Message<"livekit.proto.OwnedBuffer"> & {
+declare class OwnedBuffer extends Message<OwnedBuffer> {
     /**
      * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
      */
@@ -1095,20 +1326,23 @@ export type OwnedBuffer = Message<"livekit.proto.OwnedBuffer"> & {
      * @generated from field: required livekit.proto.BufferInfo data = 2;
      */
     data?: BufferInfo;
-};
-/**
- * Describes the message livekit.proto.OwnedBuffer.
- * Use `create(OwnedBufferSchema)` to create a new message.
- */
-export declare const OwnedBufferSchema: GenMessage<OwnedBuffer>;
+    constructor(data?: PartialMessage<OwnedBuffer>);
+    static readonly runtime: typeof proto2;
+    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 type RoomEvent = Message<"livekit.proto.RoomEvent"> & {
+declare class RoomEvent extends Message<RoomEvent> {
     /**
      * @generated from field: required uint64 room_handle = 1;
      */
-    roomHandle: bigint;
+    roomHandle?: bigint;
     /**
      * @generated from oneof livekit.proto.RoomEvent.message
      */
@@ -1284,42 +1518,60 @@ export type RoomEvent = Message<"livekit.proto.RoomEvent"> & {
          */
         value: ChatMessageReceived;
         case: "chatMessage";
+    } | {
+        /**
+         * @generated from field: livekit.proto.DataStream.Header stream_header = 30;
+         */
+        value: DataStream_Header;
+        case: "streamHeader";
+    } | {
+        /**
+         * @generated from field: livekit.proto.DataStream.Chunk stream_chunk = 31;
+         */
+        value: DataStream_Chunk;
+        case: "streamChunk";
     } | {
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.RoomEvent.
- * Use `create(RoomEventSchema)` to create a new message.
- */
-export declare const RoomEventSchema: GenMessage<RoomEvent>;
+    constructor(data?: PartialMessage<RoomEvent>);
+    static readonly runtime: typeof proto2;
+    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 type RoomInfo = Message<"livekit.proto.RoomInfo"> & {
+declare class RoomInfo extends Message<RoomInfo> {
     /**
      * @generated from field: optional string sid = 1;
      */
-    sid: string;
+    sid?: string;
     /**
      * @generated from field: required string name = 2;
      */
-    name: string;
+    name?: string;
     /**
      * @generated from field: required string metadata = 3;
      */
-    metadata: string;
-};
-/**
- * Describes the message livekit.proto.RoomInfo.
- * Use `create(RoomInfoSchema)` to create a new message.
- */
-export declare const RoomInfoSchema: GenMessage<RoomInfo>;
+    metadata?: string;
+    constructor(data?: PartialMessage<RoomInfo>);
+    static readonly runtime: typeof proto2;
+    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 type OwnedRoom = Message<"livekit.proto.OwnedRoom"> & {
+declare class OwnedRoom extends Message<OwnedRoom> {
     /**
      * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
      */
@@ -1328,308 +1580,362 @@ export type OwnedRoom = Message<"livekit.proto.OwnedRoom"> & {
      * @generated from field: required livekit.proto.RoomInfo info = 2;
      */
     info?: RoomInfo;
-};
-/**
- * Describes the message livekit.proto.OwnedRoom.
- * Use `create(OwnedRoomSchema)` to create a new message.
- */
-export declare const OwnedRoomSchema: GenMessage<OwnedRoom>;
+    constructor(data?: PartialMessage<OwnedRoom>);
+    static readonly runtime: typeof proto2;
+    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 type ParticipantConnected = Message<"livekit.proto.ParticipantConnected"> & {
+declare class ParticipantConnected extends Message<ParticipantConnected> {
     /**
      * @generated from field: required livekit.proto.OwnedParticipant info = 1;
      */
     info?: OwnedParticipant;
-};
-/**
- * Describes the message livekit.proto.ParticipantConnected.
- * Use `create(ParticipantConnectedSchema)` to create a new message.
- */
-export declare const ParticipantConnectedSchema: GenMessage<ParticipantConnected>;
+    constructor(data?: PartialMessage<ParticipantConnected>);
+    static readonly runtime: typeof proto2;
+    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 type ParticipantDisconnected = Message<"livekit.proto.ParticipantDisconnected"> & {
+declare class ParticipantDisconnected extends Message<ParticipantDisconnected> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
-};
-/**
- * Describes the message livekit.proto.ParticipantDisconnected.
- * Use `create(ParticipantDisconnectedSchema)` to create a new message.
- */
-export declare const ParticipantDisconnectedSchema: GenMessage<ParticipantDisconnected>;
+    participantIdentity?: string;
+    constructor(data?: PartialMessage<ParticipantDisconnected>);
+    static readonly runtime: typeof proto2;
+    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 type LocalTrackPublished = Message<"livekit.proto.LocalTrackPublished"> & {
+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: required string track_sid = 1;
      */
-    trackSid: string;
-};
-/**
- * Describes the message livekit.proto.LocalTrackPublished.
- * Use `create(LocalTrackPublishedSchema)` to create a new message.
- */
-export declare const LocalTrackPublishedSchema: GenMessage<LocalTrackPublished>;
+    trackSid?: string;
+    constructor(data?: PartialMessage<LocalTrackPublished>);
+    static readonly runtime: typeof proto2;
+    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 type LocalTrackUnpublished = Message<"livekit.proto.LocalTrackUnpublished"> & {
+declare class LocalTrackUnpublished extends Message<LocalTrackUnpublished> {
     /**
      * @generated from field: required string publication_sid = 1;
      */
-    publicationSid: string;
-};
-/**
- * Describes the message livekit.proto.LocalTrackUnpublished.
- * Use `create(LocalTrackUnpublishedSchema)` to create a new message.
- */
-export declare const LocalTrackUnpublishedSchema: GenMessage<LocalTrackUnpublished>;
+    publicationSid?: string;
+    constructor(data?: PartialMessage<LocalTrackUnpublished>);
+    static readonly runtime: typeof proto2;
+    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.LocalTrackSubscribed
  */
-export type LocalTrackSubscribed = Message<"livekit.proto.LocalTrackSubscribed"> & {
+declare class LocalTrackSubscribed extends Message<LocalTrackSubscribed> {
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
-};
-/**
- * Describes the message livekit.proto.LocalTrackSubscribed.
- * Use `create(LocalTrackSubscribedSchema)` to create a new message.
- */
-export declare const LocalTrackSubscribedSchema: GenMessage<LocalTrackSubscribed>;
+    trackSid?: string;
+    constructor(data?: PartialMessage<LocalTrackSubscribed>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.LocalTrackSubscribed";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LocalTrackSubscribed;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LocalTrackSubscribed;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LocalTrackSubscribed;
+    static equals(a: LocalTrackSubscribed | PlainMessage<LocalTrackSubscribed> | undefined, b: LocalTrackSubscribed | PlainMessage<LocalTrackSubscribed> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.TrackPublished
  */
-export type TrackPublished = Message<"livekit.proto.TrackPublished"> & {
+declare class TrackPublished extends Message<TrackPublished> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required livekit.proto.OwnedTrackPublication publication = 2;
      */
     publication?: OwnedTrackPublication;
-};
-/**
- * Describes the message livekit.proto.TrackPublished.
- * Use `create(TrackPublishedSchema)` to create a new message.
- */
-export declare const TrackPublishedSchema: GenMessage<TrackPublished>;
+    constructor(data?: PartialMessage<TrackPublished>);
+    static readonly runtime: typeof proto2;
+    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 type TrackUnpublished = Message<"livekit.proto.TrackUnpublished"> & {
+declare class TrackUnpublished extends Message<TrackUnpublished> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string publication_sid = 2;
      */
-    publicationSid: string;
-};
-/**
- * Describes the message livekit.proto.TrackUnpublished.
- * Use `create(TrackUnpublishedSchema)` to create a new message.
- */
-export declare const TrackUnpublishedSchema: GenMessage<TrackUnpublished>;
+    publicationSid?: string;
+    constructor(data?: PartialMessage<TrackUnpublished>);
+    static readonly runtime: typeof proto2;
+    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 type TrackSubscribed = Message<"livekit.proto.TrackSubscribed"> & {
+declare class TrackSubscribed extends Message<TrackSubscribed> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required livekit.proto.OwnedTrack track = 2;
      */
     track?: OwnedTrack;
-};
-/**
- * Describes the message livekit.proto.TrackSubscribed.
- * Use `create(TrackSubscribedSchema)` to create a new message.
- */
-export declare const TrackSubscribedSchema: GenMessage<TrackSubscribed>;
+    constructor(data?: PartialMessage<TrackSubscribed>);
+    static readonly runtime: typeof proto2;
+    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 type TrackUnsubscribed = Message<"livekit.proto.TrackUnsubscribed"> & {
+declare class TrackUnsubscribed extends Message<TrackUnsubscribed> {
     /**
      * The FFI language can dispose/remove the VideoSink here
      *
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
-};
-/**
- * Describes the message livekit.proto.TrackUnsubscribed.
- * Use `create(TrackUnsubscribedSchema)` to create a new message.
- */
-export declare const TrackUnsubscribedSchema: GenMessage<TrackUnsubscribed>;
+    trackSid?: string;
+    constructor(data?: PartialMessage<TrackUnsubscribed>);
+    static readonly runtime: typeof proto2;
+    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 type TrackSubscriptionFailed = Message<"livekit.proto.TrackSubscriptionFailed"> & {
+declare class TrackSubscriptionFailed extends Message<TrackSubscriptionFailed> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
+    trackSid?: string;
     /**
      * @generated from field: required string error = 3;
      */
-    error: string;
-};
-/**
- * Describes the message livekit.proto.TrackSubscriptionFailed.
- * Use `create(TrackSubscriptionFailedSchema)` to create a new message.
- */
-export declare const TrackSubscriptionFailedSchema: GenMessage<TrackSubscriptionFailed>;
+    error?: string;
+    constructor(data?: PartialMessage<TrackSubscriptionFailed>);
+    static readonly runtime: typeof proto2;
+    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 type TrackMuted = Message<"livekit.proto.TrackMuted"> & {
+declare class TrackMuted extends Message<TrackMuted> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
-};
-/**
- * Describes the message livekit.proto.TrackMuted.
- * Use `create(TrackMutedSchema)` to create a new message.
- */
-export declare const TrackMutedSchema: GenMessage<TrackMuted>;
+    trackSid?: string;
+    constructor(data?: PartialMessage<TrackMuted>);
+    static readonly runtime: typeof proto2;
+    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 type TrackUnmuted = Message<"livekit.proto.TrackUnmuted"> & {
+declare class TrackUnmuted extends Message<TrackUnmuted> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string track_sid = 2;
      */
-    trackSid: string;
-};
-/**
- * Describes the message livekit.proto.TrackUnmuted.
- * Use `create(TrackUnmutedSchema)` to create a new message.
- */
-export declare const TrackUnmutedSchema: GenMessage<TrackUnmuted>;
+    trackSid?: string;
+    constructor(data?: PartialMessage<TrackUnmuted>);
+    static readonly runtime: typeof proto2;
+    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 type E2eeStateChanged = Message<"livekit.proto.E2eeStateChanged"> & {
+declare class E2eeStateChanged extends Message<E2eeStateChanged> {
     /**
      * Using sid instead of identity for ffi communication
      *
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required livekit.proto.EncryptionState state = 2;
      */
-    state: EncryptionState;
-};
-/**
- * Describes the message livekit.proto.E2eeStateChanged.
- * Use `create(E2eeStateChangedSchema)` to create a new message.
- */
-export declare const E2eeStateChangedSchema: GenMessage<E2eeStateChanged>;
+    state?: EncryptionState;
+    constructor(data?: PartialMessage<E2eeStateChanged>);
+    static readonly runtime: typeof proto2;
+    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 type ActiveSpeakersChanged = Message<"livekit.proto.ActiveSpeakersChanged"> & {
+declare class ActiveSpeakersChanged extends Message<ActiveSpeakersChanged> {
     /**
      * @generated from field: repeated string participant_identities = 1;
      */
     participantIdentities: string[];
-};
-/**
- * Describes the message livekit.proto.ActiveSpeakersChanged.
- * Use `create(ActiveSpeakersChangedSchema)` to create a new message.
- */
-export declare const ActiveSpeakersChangedSchema: GenMessage<ActiveSpeakersChanged>;
+    constructor(data?: PartialMessage<ActiveSpeakersChanged>);
+    static readonly runtime: typeof proto2;
+    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 type RoomMetadataChanged = Message<"livekit.proto.RoomMetadataChanged"> & {
+declare class RoomMetadataChanged extends Message<RoomMetadataChanged> {
     /**
      * @generated from field: required string metadata = 1;
      */
-    metadata: string;
-};
-/**
- * Describes the message livekit.proto.RoomMetadataChanged.
- * Use `create(RoomMetadataChangedSchema)` to create a new message.
- */
-export declare const RoomMetadataChangedSchema: GenMessage<RoomMetadataChanged>;
+    metadata?: string;
+    constructor(data?: PartialMessage<RoomMetadataChanged>);
+    static readonly runtime: typeof proto2;
+    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.RoomSidChanged
  */
-export type RoomSidChanged = Message<"livekit.proto.RoomSidChanged"> & {
+declare class RoomSidChanged extends Message<RoomSidChanged> {
     /**
      * @generated from field: required string sid = 1;
      */
-    sid: string;
-};
-/**
- * Describes the message livekit.proto.RoomSidChanged.
- * Use `create(RoomSidChangedSchema)` to create a new message.
- */
-export declare const RoomSidChangedSchema: GenMessage<RoomSidChanged>;
+    sid?: string;
+    constructor(data?: PartialMessage<RoomSidChanged>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.RoomSidChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomSidChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomSidChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomSidChanged;
+    static equals(a: RoomSidChanged | PlainMessage<RoomSidChanged> | undefined, b: RoomSidChanged | PlainMessage<RoomSidChanged> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.ParticipantMetadataChanged
  */
-export type ParticipantMetadataChanged = Message<"livekit.proto.ParticipantMetadataChanged"> & {
+declare class ParticipantMetadataChanged extends Message<ParticipantMetadataChanged> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string metadata = 2;
      */
-    metadata: string;
-};
-/**
- * Describes the message livekit.proto.ParticipantMetadataChanged.
- * Use `create(ParticipantMetadataChangedSchema)` to create a new message.
- */
-export declare const ParticipantMetadataChangedSchema: GenMessage<ParticipantMetadataChanged>;
+    metadata?: string;
+    constructor(data?: PartialMessage<ParticipantMetadataChanged>);
+    static readonly runtime: typeof proto2;
+    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.ParticipantAttributesChanged
  */
-export type ParticipantAttributesChanged = Message<"livekit.proto.ParticipantAttributesChanged"> & {
+declare class ParticipantAttributesChanged extends Message<ParticipantAttributesChanged> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: repeated livekit.proto.AttributesEntry attributes = 2;
      */
@@ -1638,52 +1944,61 @@ export type ParticipantAttributesChanged = Message<"livekit.proto.ParticipantAtt
      * @generated from field: repeated livekit.proto.AttributesEntry changed_attributes = 3;
      */
     changedAttributes: AttributesEntry[];
-};
-/**
- * Describes the message livekit.proto.ParticipantAttributesChanged.
- * Use `create(ParticipantAttributesChangedSchema)` to create a new message.
- */
-export declare const ParticipantAttributesChangedSchema: GenMessage<ParticipantAttributesChanged>;
+    constructor(data?: PartialMessage<ParticipantAttributesChanged>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.ParticipantAttributesChanged";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantAttributesChanged;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantAttributesChanged;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantAttributesChanged;
+    static equals(a: ParticipantAttributesChanged | PlainMessage<ParticipantAttributesChanged> | undefined, b: ParticipantAttributesChanged | PlainMessage<ParticipantAttributesChanged> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.ParticipantNameChanged
  */
-export type ParticipantNameChanged = Message<"livekit.proto.ParticipantNameChanged"> & {
+declare class ParticipantNameChanged extends Message<ParticipantNameChanged> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required string name = 2;
      */
-    name: string;
-};
-/**
- * Describes the message livekit.proto.ParticipantNameChanged.
- * Use `create(ParticipantNameChangedSchema)` to create a new message.
- */
-export declare const ParticipantNameChangedSchema: GenMessage<ParticipantNameChanged>;
+    name?: string;
+    constructor(data?: PartialMessage<ParticipantNameChanged>);
+    static readonly runtime: typeof proto2;
+    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 type ConnectionQualityChanged = Message<"livekit.proto.ConnectionQualityChanged"> & {
+declare class ConnectionQualityChanged extends Message<ConnectionQualityChanged> {
     /**
      * @generated from field: required string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: required livekit.proto.ConnectionQuality quality = 2;
      */
-    quality: ConnectionQuality;
-};
-/**
- * Describes the message livekit.proto.ConnectionQualityChanged.
- * Use `create(ConnectionQualityChangedSchema)` to create a new message.
- */
-export declare const ConnectionQualityChangedSchema: GenMessage<ConnectionQualityChanged>;
+    quality?: ConnectionQuality;
+    constructor(data?: PartialMessage<ConnectionQualityChanged>);
+    static readonly runtime: typeof proto2;
+    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.UserPacket
  */
-export type UserPacket = Message<"livekit.proto.UserPacket"> & {
+declare class UserPacket extends Message<UserPacket> {
     /**
      * @generated from field: required livekit.proto.OwnedBuffer data = 1;
      */
@@ -1691,51 +2006,57 @@ export type UserPacket = Message<"livekit.proto.UserPacket"> & {
     /**
      * @generated from field: optional string topic = 2;
      */
-    topic: string;
-};
-/**
- * Describes the message livekit.proto.UserPacket.
- * Use `create(UserPacketSchema)` to create a new message.
- */
-export declare const UserPacketSchema: GenMessage<UserPacket>;
+    topic?: string;
+    constructor(data?: PartialMessage<UserPacket>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.UserPacket";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UserPacket;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UserPacket;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UserPacket;
+    static equals(a: UserPacket | PlainMessage<UserPacket> | undefined, b: UserPacket | PlainMessage<UserPacket> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.ChatMessage
  */
-export type ChatMessage = Message<"livekit.proto.ChatMessage"> & {
+declare class ChatMessage extends Message<ChatMessage> {
     /**
      * @generated from field: required string id = 1;
      */
-    id: string;
+    id?: string;
     /**
      * @generated from field: required int64 timestamp = 2;
      */
-    timestamp: bigint;
+    timestamp?: bigint;
     /**
      * @generated from field: required string message = 3;
      */
-    message: string;
+    message?: string;
     /**
      * @generated from field: optional int64 edit_timestamp = 4;
      */
-    editTimestamp: bigint;
+    editTimestamp?: bigint;
     /**
      * @generated from field: optional bool deleted = 5;
      */
-    deleted: boolean;
+    deleted?: boolean;
     /**
      * @generated from field: optional bool generated = 6;
      */
-    generated: boolean;
-};
-/**
- * Describes the message livekit.proto.ChatMessage.
- * Use `create(ChatMessageSchema)` to create a new message.
- */
-export declare const ChatMessageSchema: GenMessage<ChatMessage>;
+    generated?: boolean;
+    constructor(data?: PartialMessage<ChatMessage>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.ChatMessage";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChatMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChatMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChatMessage;
+    static equals(a: ChatMessage | PlainMessage<ChatMessage> | undefined, b: ChatMessage | PlainMessage<ChatMessage> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.ChatMessageReceived
  */
-export type ChatMessageReceived = Message<"livekit.proto.ChatMessageReceived"> & {
+declare class ChatMessageReceived extends Message<ChatMessageReceived> {
     /**
      * @generated from field: required livekit.proto.ChatMessage message = 1;
      */
@@ -1743,45 +2064,51 @@ export type ChatMessageReceived = Message<"livekit.proto.ChatMessageReceived"> &
     /**
      * @generated from field: required string participant_identity = 2;
      */
-    participantIdentity: string;
-};
-/**
- * Describes the message livekit.proto.ChatMessageReceived.
- * Use `create(ChatMessageReceivedSchema)` to create a new message.
- */
-export declare const ChatMessageReceivedSchema: GenMessage<ChatMessageReceived>;
+    participantIdentity?: string;
+    constructor(data?: PartialMessage<ChatMessageReceived>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.ChatMessageReceived";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChatMessageReceived;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChatMessageReceived;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChatMessageReceived;
+    static equals(a: ChatMessageReceived | PlainMessage<ChatMessageReceived> | undefined, b: ChatMessageReceived | PlainMessage<ChatMessageReceived> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.SipDTMF
  */
-export type SipDTMF = Message<"livekit.proto.SipDTMF"> & {
+declare class SipDTMF extends Message<SipDTMF> {
     /**
      * @generated from field: required uint32 code = 1;
      */
-    code: number;
+    code?: number;
     /**
      * @generated from field: optional string digit = 2;
      */
-    digit: string;
-};
-/**
- * Describes the message livekit.proto.SipDTMF.
- * Use `create(SipDTMFSchema)` to create a new message.
- */
-export declare const SipDTMFSchema: GenMessage<SipDTMF>;
+    digit?: string;
+    constructor(data?: PartialMessage<SipDTMF>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.SipDTMF";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipDTMF;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipDTMF;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipDTMF;
+    static equals(a: SipDTMF | PlainMessage<SipDTMF> | undefined, b: SipDTMF | PlainMessage<SipDTMF> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.DataPacketReceived
  */
-export type DataPacketReceived = Message<"livekit.proto.DataPacketReceived"> & {
+declare class DataPacketReceived extends Message<DataPacketReceived> {
     /**
      * @generated from field: required livekit.proto.DataPacketKind kind = 1;
      */
-    kind: DataPacketKind;
+    kind?: DataPacketKind;
     /**
      * Can be empty if the data is sent a server SDK
      *
      * @generated from field: required string participant_identity = 2;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from oneof livekit.proto.DataPacketReceived.value
      */
@@ -1801,270 +2128,348 @@ export type DataPacketReceived = Message<"livekit.proto.DataPacketReceived"> & {
         case: undefined;
         value?: undefined;
     };
-};
-/**
- * Describes the message livekit.proto.DataPacketReceived.
- * Use `create(DataPacketReceivedSchema)` to create a new message.
- */
-export declare const DataPacketReceivedSchema: GenMessage<DataPacketReceived>;
+    constructor(data?: PartialMessage<DataPacketReceived>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataPacketReceived";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataPacketReceived;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataPacketReceived;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataPacketReceived;
+    static equals(a: DataPacketReceived | PlainMessage<DataPacketReceived> | undefined, b: DataPacketReceived | PlainMessage<DataPacketReceived> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.TranscriptionReceived
  */
-export type TranscriptionReceived = Message<"livekit.proto.TranscriptionReceived"> & {
+declare class TranscriptionReceived extends Message<TranscriptionReceived> {
     /**
      * @generated from field: optional string participant_identity = 1;
      */
-    participantIdentity: string;
+    participantIdentity?: string;
     /**
      * @generated from field: optional string track_sid = 2;
      */
-    trackSid: string;
+    trackSid?: string;
     /**
      * @generated from field: repeated livekit.proto.TranscriptionSegment segments = 3;
      */
     segments: TranscriptionSegment[];
-};
-/**
- * Describes the message livekit.proto.TranscriptionReceived.
- * Use `create(TranscriptionReceivedSchema)` to create a new message.
- */
-export declare const TranscriptionReceivedSchema: GenMessage<TranscriptionReceived>;
+    constructor(data?: PartialMessage<TranscriptionReceived>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.TranscriptionReceived";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TranscriptionReceived;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TranscriptionReceived;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TranscriptionReceived;
+    static equals(a: TranscriptionReceived | PlainMessage<TranscriptionReceived> | undefined, b: TranscriptionReceived | PlainMessage<TranscriptionReceived> | undefined): boolean;
+}
 /**
  * @generated from message livekit.proto.ConnectionStateChanged
  */
-export type ConnectionStateChanged = Message<"livekit.proto.ConnectionStateChanged"> & {
+declare class ConnectionStateChanged extends Message<ConnectionStateChanged> {
     /**
      * @generated from field: required livekit.proto.ConnectionState state = 1;
      */
-    state: ConnectionState;
-};
-/**
- * Describes the message livekit.proto.ConnectionStateChanged.
- * Use `create(ConnectionStateChangedSchema)` to create a new message.
- */
-export declare const ConnectionStateChangedSchema: GenMessage<ConnectionStateChanged>;
+    state?: ConnectionState;
+    constructor(data?: PartialMessage<ConnectionStateChanged>);
+    static readonly runtime: typeof proto2;
+    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 type Connected = Message<"livekit.proto.Connected"> & {};
-/**
- * Describes the message livekit.proto.Connected.
- * Use `create(ConnectedSchema)` to create a new message.
- */
-export declare const ConnectedSchema: GenMessage<Connected>;
+declare class Connected extends Message<Connected> {
+    constructor(data?: PartialMessage<Connected>);
+    static readonly runtime: typeof proto2;
+    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 type Disconnected = Message<"livekit.proto.Disconnected"> & {
+declare class Disconnected extends Message<Disconnected> {
     /**
      * @generated from field: required livekit.proto.DisconnectReason reason = 1;
      */
-    reason: DisconnectReason;
-};
-/**
- * Describes the message livekit.proto.Disconnected.
- * Use `create(DisconnectedSchema)` to create a new message.
- */
-export declare const DisconnectedSchema: GenMessage<Disconnected>;
+    reason?: DisconnectReason;
+    constructor(data?: PartialMessage<Disconnected>);
+    static readonly runtime: typeof proto2;
+    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 type Reconnecting = Message<"livekit.proto.Reconnecting"> & {};
-/**
- * Describes the message livekit.proto.Reconnecting.
- * Use `create(ReconnectingSchema)` to create a new message.
- */
-export declare const ReconnectingSchema: GenMessage<Reconnecting>;
+declare class Reconnecting extends Message<Reconnecting> {
+    constructor(data?: PartialMessage<Reconnecting>);
+    static readonly runtime: typeof proto2;
+    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 type Reconnected = Message<"livekit.proto.Reconnected"> & {};
-/**
- * Describes the message livekit.proto.Reconnected.
- * Use `create(ReconnectedSchema)` to create a new message.
- */
-export declare const ReconnectedSchema: GenMessage<Reconnected>;
+declare class Reconnected extends Message<Reconnected> {
+    constructor(data?: PartialMessage<Reconnected>);
+    static readonly runtime: typeof proto2;
+    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 type RoomEOS = Message<"livekit.proto.RoomEOS"> & {};
+declare class RoomEOS extends Message<RoomEOS> {
+    constructor(data?: PartialMessage<RoomEOS>);
+    static readonly runtime: typeof proto2;
+    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;
+}
 /**
- * Describes the message livekit.proto.RoomEOS.
- * Use `create(RoomEOSSchema)` to create a new message.
- */
-export declare const RoomEOSSchema: GenMessage<RoomEOS>;
+ * @generated from message livekit.proto.DataStream
+ */
+declare class DataStream extends Message<DataStream> {
+    constructor(data?: PartialMessage<DataStream>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataStream";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream;
+    static equals(a: DataStream | PlainMessage<DataStream> | undefined, b: DataStream | PlainMessage<DataStream> | undefined): boolean;
+}
 /**
- * @generated from enum livekit.proto.IceTransportType
+ * enum for operation types (specific to TextHeader)
+ *
+ * @generated from enum livekit.proto.DataStream.OperationType
  */
-export declare enum IceTransportType {
+declare enum DataStream_OperationType {
     /**
-     * @generated from enum value: TRANSPORT_RELAY = 0;
-     */
-    TRANSPORT_RELAY = 0,
-    /**
-     * @generated from enum value: TRANSPORT_NOHOST = 1;
+     * @generated from enum value: CREATE = 0;
      */
-    TRANSPORT_NOHOST = 1,
+    CREATE = 0,
     /**
-     * @generated from enum value: TRANSPORT_ALL = 2;
+     * @generated from enum value: UPDATE = 1;
      */
-    TRANSPORT_ALL = 2
-}
-/**
- * Describes the enum livekit.proto.IceTransportType.
- */
-export declare const IceTransportTypeSchema: GenEnum<IceTransportType>;
-/**
- * @generated from enum livekit.proto.ContinualGatheringPolicy
- */
-export declare enum ContinualGatheringPolicy {
+    UPDATE = 1,
     /**
-     * @generated from enum value: GATHER_ONCE = 0;
+     * @generated from enum value: DELETE = 2;
      */
-    GATHER_ONCE = 0,
+    DELETE = 2,
     /**
-     * @generated from enum value: GATHER_CONTINUALLY = 1;
+     * @generated from enum value: REACTION = 3;
      */
-    GATHER_CONTINUALLY = 1
+    REACTION = 3
 }
 /**
- * Describes the enum livekit.proto.ContinualGatheringPolicy.
- */
-export declare const ContinualGatheringPolicySchema: GenEnum<ContinualGatheringPolicy>;
-/**
- * @generated from enum livekit.proto.ConnectionQuality
+ * header properties specific to text streams
+ *
+ * @generated from message livekit.proto.DataStream.TextHeader
  */
-export declare enum ConnectionQuality {
+declare class DataStream_TextHeader extends Message<DataStream_TextHeader> {
     /**
-     * @generated from enum value: QUALITY_POOR = 0;
+     * @generated from field: required livekit.proto.DataStream.OperationType operation_type = 1;
      */
-    QUALITY_POOR = 0,
+    operationType?: DataStream_OperationType;
     /**
-     * @generated from enum value: QUALITY_GOOD = 1;
+     * Optional: Version for updates/edits
+     *
+     * @generated from field: required int32 version = 2;
      */
-    QUALITY_GOOD = 1,
+    version?: number;
     /**
-     * @generated from enum value: QUALITY_EXCELLENT = 2;
+     * Optional: Reply to specific message
+     *
+     * @generated from field: required string reply_to_stream_id = 3;
      */
-    QUALITY_EXCELLENT = 2,
+    replyToStreamId?: string;
     /**
-     * @generated from enum value: QUALITY_LOST = 3;
+     * file attachments for text streams
+     *
+     * @generated from field: repeated string attached_stream_ids = 4;
      */
-    QUALITY_LOST = 3
+    attachedStreamIds: string[];
+    /**
+     * true if the text has been generated by an agent from a participant's audio transcription
+     *
+     * @generated from field: required bool generated = 5;
+     */
+    generated?: boolean;
+    constructor(data?: PartialMessage<DataStream_TextHeader>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataStream.TextHeader";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_TextHeader;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_TextHeader;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_TextHeader;
+    static equals(a: DataStream_TextHeader | PlainMessage<DataStream_TextHeader> | undefined, b: DataStream_TextHeader | PlainMessage<DataStream_TextHeader> | undefined): boolean;
 }
 /**
- * Describes the enum livekit.proto.ConnectionQuality.
- */
-export declare const ConnectionQualitySchema: GenEnum<ConnectionQuality>;
-/**
- * @generated from enum livekit.proto.ConnectionState
+ * header properties specific to file or image streams
+ *
+ * @generated from message livekit.proto.DataStream.FileHeader
  */
-export declare enum ConnectionState {
-    /**
-     * @generated from enum value: CONN_DISCONNECTED = 0;
-     */
-    CONN_DISCONNECTED = 0,
-    /**
-     * @generated from enum value: CONN_CONNECTED = 1;
-     */
-    CONN_CONNECTED = 1,
+declare class DataStream_FileHeader extends Message<DataStream_FileHeader> {
     /**
-     * @generated from enum value: CONN_RECONNECTING = 2;
-     */
-    CONN_RECONNECTING = 2
+     * name of the file
+     *
+     * @generated from field: required string file_name = 1;
+     */
+    fileName?: string;
+    constructor(data?: PartialMessage<DataStream_FileHeader>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataStream.FileHeader";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_FileHeader;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_FileHeader;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_FileHeader;
+    static equals(a: DataStream_FileHeader | PlainMessage<DataStream_FileHeader> | undefined, b: DataStream_FileHeader | PlainMessage<DataStream_FileHeader> | undefined): boolean;
 }
 /**
- * Describes the enum livekit.proto.ConnectionState.
- */
-export declare const ConnectionStateSchema: GenEnum<ConnectionState>;
-/**
- * @generated from enum livekit.proto.DataPacketKind
+ * main DataStream.Header that contains a oneof for specific headers
+ *
+ * @generated from message livekit.proto.DataStream.Header
  */
-export declare enum DataPacketKind {
+declare class DataStream_Header extends Message<DataStream_Header> {
     /**
-     * @generated from enum value: KIND_LOSSY = 0;
+     * unique identifier for this data stream
+     *
+     * @generated from field: required string stream_id = 1;
      */
-    KIND_LOSSY = 0,
+    streamId?: string;
     /**
-     * @generated from enum value: KIND_RELIABLE = 1;
+     * using int64 for Unix timestamp
+     *
+     * @generated from field: required int64 timestamp = 2;
      */
-    KIND_RELIABLE = 1
-}
-/**
- * Describes the enum livekit.proto.DataPacketKind.
- */
-export declare const DataPacketKindSchema: GenEnum<DataPacketKind>;
-/**
- * @generated from enum livekit.proto.DisconnectReason
- */
-export declare enum DisconnectReason {
+    timestamp?: bigint;
     /**
-     * @generated from enum value: UNKNOWN_REASON = 0;
+     * @generated from field: required string topic = 3;
      */
-    UNKNOWN_REASON = 0,
+    topic?: string;
     /**
-     * the client initiated the disconnect
-     *
-     * @generated from enum value: CLIENT_INITIATED = 1;
+     * @generated from field: required string mime_type = 4;
      */
-    CLIENT_INITIATED = 1,
+    mimeType?: string;
     /**
-     * another participant with the same identity has joined the room
+     * only populated for finite streams, if it's a stream of unknown size this stays empty
      *
-     * @generated from enum value: DUPLICATE_IDENTITY = 2;
+     * @generated from field: optional uint64 total_length = 5;
      */
-    DUPLICATE_IDENTITY = 2,
+    totalLength?: bigint;
     /**
-     * the server instance is shutting down
+     * only populated for finite streams, if it's a stream of unknown size this stays empty
      *
-     * @generated from enum value: SERVER_SHUTDOWN = 3;
+     * @generated from field: optional uint64 total_chunks = 6;
      */
-    SERVER_SHUTDOWN = 3,
+    totalChunks?: bigint;
     /**
-     * RoomService.RemoveParticipant was called
+     * user defined extensions map that can carry additional info
      *
-     * @generated from enum value: PARTICIPANT_REMOVED = 4;
+     * @generated from field: map<string, string> extensions = 7;
      */
-    PARTICIPANT_REMOVED = 4,
+    extensions: {
+        [key: string]: string;
+    };
     /**
-     * RoomService.DeleteRoom was called
+     * oneof to choose between specific header types
      *
-     * @generated from enum value: ROOM_DELETED = 5;
+     * @generated from oneof livekit.proto.DataStream.Header.content_header
      */
-    ROOM_DELETED = 5,
+    contentHeader: {
+        /**
+         * @generated from field: livekit.proto.DataStream.TextHeader text_header = 8;
+         */
+        value: DataStream_TextHeader;
+        case: "textHeader";
+    } | {
+        /**
+         * @generated from field: livekit.proto.DataStream.FileHeader file_header = 9;
+         */
+        value: DataStream_FileHeader;
+        case: "fileHeader";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<DataStream_Header>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataStream.Header";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Header;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_Header;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_Header;
+    static equals(a: DataStream_Header | PlainMessage<DataStream_Header> | undefined, b: DataStream_Header | PlainMessage<DataStream_Header> | undefined): boolean;
+}
+/**
+ * @generated from message livekit.proto.DataStream.Chunk
+ */
+declare class DataStream_Chunk extends Message<DataStream_Chunk> {
     /**
-     * the client is attempting to resume a session, but server is not aware of it
+     * unique identifier for this data stream to map it to the correct header
      *
-     * @generated from enum value: STATE_MISMATCH = 6;
+     * @generated from field: required string stream_id = 1;
      */
-    STATE_MISMATCH = 6,
+    streamId?: string;
     /**
-     * client was unable to connect fully
-     *
-     * @generated from enum value: JOIN_FAILURE = 7;
+     * @generated from field: required uint64 chunk_index = 2;
      */
-    JOIN_FAILURE = 7,
+    chunkIndex?: bigint;
     /**
-     * Cloud-only, the server requested Participant to migrate the connection elsewhere
+     * content as binary (bytes)
      *
-     * @generated from enum value: MIGRATION = 8;
+     * @generated from field: required bytes content = 3;
      */
-    MIGRATION = 8,
+    content?: Uint8Array;
     /**
-     * the signal websocket was closed unexpectedly
+     * true only if this is the last chunk of this stream - can also be sent with empty content
      *
-     * @generated from enum value: SIGNAL_CLOSE = 9;
+     * @generated from field: required bool complete = 4;
      */
-    SIGNAL_CLOSE = 9,
+    complete?: boolean;
     /**
-     * the room was closed, due to all Standard and Ingress participants having left
+     * a version indicating that this chunk_index has been retroactively modified and the original one needs to be replaced
      *
-     * @generated from enum value: ROOM_CLOSED = 10;
+     * @generated from field: required int32 version = 5;
      */
-    ROOM_CLOSED = 10
+    version?: number;
+    /**
+     * optional, initialization vector for AES-GCM encryption
+     *
+     * @generated from field: optional bytes iv = 6;
+     */
+    iv?: Uint8Array;
+    constructor(data?: PartialMessage<DataStream_Chunk>);
+    static readonly runtime: typeof proto2;
+    static readonly typeName = "livekit.proto.DataStream.Chunk";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Chunk;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_Chunk;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_Chunk;
+    static equals(a: DataStream_Chunk | PlainMessage<DataStream_Chunk> | undefined, b: DataStream_Chunk | PlainMessage<DataStream_Chunk> | undefined): boolean;
 }
-/**
- * Describes the enum livekit.proto.DisconnectReason.
- */
-export declare const DisconnectReasonSchema: GenEnum<DisconnectReason>;
-//# sourceMappingURL=room_pb.d.ts.map
+
+export { ActiveSpeakersChanged, AttributesEntry, AudioEncoding, BufferInfo, ChatMessage, ChatMessageReceived, ConnectCallback, ConnectCallback_ParticipantWithTracks, ConnectCallback_Result, ConnectRequest, ConnectResponse, Connected, ConnectionQuality, ConnectionQualityChanged, ConnectionState, ConnectionStateChanged, ContinualGatheringPolicy, DataPacketKind, DataPacketReceived, DataStream, DataStream_Chunk, DataStream_FileHeader, DataStream_Header, DataStream_OperationType, DataStream_TextHeader, DisconnectCallback, DisconnectRequest, DisconnectResponse, Disconnected, E2eeStateChanged, EditChatMessageRequest, GetSessionStatsCallback, GetSessionStatsCallback_Result, GetSessionStatsRequest, GetSessionStatsResponse, IceServer, IceTransportType, LocalTrackPublished, LocalTrackSubscribed, LocalTrackUnpublished, OwnedBuffer, OwnedRoom, ParticipantAttributesChanged, ParticipantConnected, ParticipantDisconnected, ParticipantMetadataChanged, ParticipantNameChanged, PublishDataCallback, PublishDataRequest, PublishDataResponse, PublishSipDtmfCallback, PublishSipDtmfRequest, PublishSipDtmfResponse, PublishTrackCallback, PublishTrackRequest, PublishTrackResponse, PublishTranscriptionCallback, PublishTranscriptionRequest, PublishTranscriptionResponse, Reconnected, Reconnecting, RoomEOS, RoomEvent, RoomInfo, RoomMetadataChanged, RoomOptions, RoomSidChanged, RtcConfig, SendChatMessageCallback, SendChatMessageRequest, SendChatMessageResponse, SetLocalAttributesCallback, SetLocalAttributesRequest, SetLocalAttributesResponse, SetLocalMetadataCallback, SetLocalMetadataRequest, SetLocalMetadataResponse, SetLocalNameCallback, SetLocalNameRequest, SetLocalNameResponse, SetSubscribedRequest, SetSubscribedResponse, SipDTMF, TrackMuted, TrackPublishOptions, TrackPublished, TrackSubscribed, TrackSubscriptionFailed, TrackUnmuted, TrackUnpublished, TrackUnsubscribed, TranscriptionReceived, TranscriptionSegment, UnpublishTrackCallback, UnpublishTrackRequest, UnpublishTrackResponse, UserPacket, VideoEncoding };