// Copyright 2025 LiveKit, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// @generated by protoc-gen-es v1.10.1 with parameter "js_import_style=legacy_commonjs"
// @generated from file room.proto (package livekit.proto, syntax proto2)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto2 } from "@bufbuild/protobuf";
import type { DisconnectReason, OwnedParticipant, ParticipantInfo, ParticipantPermission } from "./participant_pb.js";
import type { FrameMetadataFeature, OwnedTrack, OwnedTrackPublication, TrackPublicationInfo, TrackSource } from "./track_pb.js";
import type { RtcStats } from "./stats_pb.js";
import type { VideoCodec } from "./video_frame_pb.js";
import type { E2eeOptions, EncryptionState } from "./e2ee_pb.js";
import type { FfiOwnedHandle } from "./handle_pb.js";
import type { OwnedByteStreamReader, OwnedTextStreamReader } from "./data_stream_pb.js";
import type { OwnedRemoteDataTrack } from "./data_track_pb.js";

/**
 * Simulate a reconnection scenario for testing. Mirrors the variants of
 * `livekit::SimulateScenario`. The Resume / FullReconnect variants are
 * the relevant ones for verifying that resume preserves publications and
 * full reconnect republishes them exactly once.
 *
 * @generated from enum livekit.proto.SimulateScenarioKind
 */
export declare enum SimulateScenarioKind {
  /**
   * Closes the signal channel locally; engine attempts a Resume.
   *
   * @generated from enum value: SIMULATE_SIGNAL_RECONNECT = 0;
   */
  SIMULATE_SIGNAL_RECONNECT = 0,

  /**
   * @generated from enum value: SIMULATE_SPEAKER = 1;
   */
  SIMULATE_SPEAKER = 1,

  /**
   * @generated from enum value: SIMULATE_NODE_FAILURE = 2;
   */
  SIMULATE_NODE_FAILURE = 2,

  /**
   * @generated from enum value: SIMULATE_SERVER_LEAVE = 3;
   */
  SIMULATE_SERVER_LEAVE = 3,

  /**
   * @generated from enum value: SIMULATE_MIGRATION = 4;
   */
  SIMULATE_MIGRATION = 4,

  /**
   * @generated from enum value: SIMULATE_FORCE_TCP = 5;
   */
  SIMULATE_FORCE_TCP = 5,

  /**
   * @generated from enum value: SIMULATE_FORCE_TLS = 6;
   */
  SIMULATE_FORCE_TLS = 6,

  /**
   * Asks the server to send `LeaveRequest{Reconnect}`, forcing a full
   * reconnect (new RtcSession; SDK republishes existing local tracks).
   *
   * @generated from enum value: SIMULATE_FULL_RECONNECT = 7;
   */
  SIMULATE_FULL_RECONNECT = 7,

  /**
   * Asks the server to drop the signalling connection during the next resume,
   * then triggers a resume locally. The resume cannot complete, so the engine
   * escalates to a full reconnect — exercising the resume→full escalation path.
   *
   * @generated from enum value: SIMULATE_DISCONNECT_SIGNAL_ON_RESUME = 8;
   */
  SIMULATE_DISCONNECT_SIGNAL_ON_RESUME = 8,
}

/**
 * @generated from enum livekit.proto.VideoEncoderBackend
 */
export declare enum VideoEncoderBackend {
  /**
   * @generated from enum value: ENCODER_BACKEND_AUTO = 0;
   */
  ENCODER_BACKEND_AUTO = 0,

  /**
   * @generated from enum value: ENCODER_BACKEND_SOFTWARE = 1;
   */
  ENCODER_BACKEND_SOFTWARE = 1,

  /**
   * @generated from enum value: ENCODER_BACKEND_HARDWARE = 2;
   */
  ENCODER_BACKEND_HARDWARE = 2,

  /**
   * @generated from enum value: ENCODER_BACKEND_NVENC = 3;
   */
  ENCODER_BACKEND_NVENC = 3,

  /**
   * @generated from enum value: ENCODER_BACKEND_VAAPI = 4;
   */
  ENCODER_BACKEND_VAAPI = 4,

  /**
   * @generated from enum value: ENCODER_BACKEND_VIDEOTOOLBOX = 5;
   */
  ENCODER_BACKEND_VIDEOTOOLBOX = 5,
}

/**
 * Controls how the encoder degrades quality when bandwidth is constrained.
 *
 * @generated from enum livekit.proto.DegradationPreference
 */
export declare enum DegradationPreference {
  /**
   * Balance between framerate and resolution degradation.
   *
   * @generated from enum value: DEGRADATION_PREFERENCE_BALANCED = 0;
   */
  BALANCED = 0,

  /**
   * Degrade framerate to maintain resolution.
   *
   * @generated from enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE = 1;
   */
  MAINTAIN_FRAMERATE = 1,

  /**
   * Degrade resolution to maintain framerate (drop frames to keep clarity).
   *
   * @generated from enum value: DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION = 2;
   */
  MAINTAIN_RESOLUTION = 2,

  /**
   * Maintain both framerate and resolution. Frames may be dropped before encoding
   * if necessary to avoid overusing network and encoder resources.
   *
   * @generated from enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION = 4;
   */
  MAINTAIN_FRAMERATE_AND_RESOLUTION = 4,
}

/**
 * @generated from enum livekit.proto.IceTransportType
 */
export declare enum IceTransportType {
  /**
   * @generated from enum value: TRANSPORT_RELAY = 0;
   */
  TRANSPORT_RELAY = 0,

  /**
   * @generated from enum value: TRANSPORT_NOHOST = 1;
   */
  TRANSPORT_NOHOST = 1,

  /**
   * @generated from enum value: TRANSPORT_ALL = 2;
   */
  TRANSPORT_ALL = 2,
}

/**
 * @generated from enum livekit.proto.ContinualGatheringPolicy
 */
export declare enum ContinualGatheringPolicy {
  /**
   * @generated from enum value: GATHER_ONCE = 0;
   */
  GATHER_ONCE = 0,

  /**
   * @generated from enum value: GATHER_CONTINUALLY = 1;
   */
  GATHER_CONTINUALLY = 1,
}

/**
 * @generated from enum livekit.proto.ConnectionQuality
 */
export declare enum ConnectionQuality {
  /**
   * @generated from enum value: QUALITY_POOR = 0;
   */
  QUALITY_POOR = 0,

  /**
   * @generated from enum value: QUALITY_GOOD = 1;
   */
  QUALITY_GOOD = 1,

  /**
   * @generated from enum value: QUALITY_EXCELLENT = 2;
   */
  QUALITY_EXCELLENT = 2,

  /**
   * @generated from enum value: QUALITY_LOST = 3;
   */
  QUALITY_LOST = 3,
}

/**
 * @generated from enum livekit.proto.ConnectionState
 */
export declare enum ConnectionState {
  /**
   * @generated from enum value: CONN_DISCONNECTED = 0;
   */
  CONN_DISCONNECTED = 0,

  /**
   * @generated from enum value: CONN_CONNECTED = 1;
   */
  CONN_CONNECTED = 1,

  /**
   * @generated from enum value: CONN_RECONNECTING = 2;
   */
  CONN_RECONNECTING = 2,
}

/**
 * @generated from enum livekit.proto.DataPacketKind
 */
export declare enum DataPacketKind {
  /**
   * @generated from enum value: KIND_LOSSY = 0;
   */
  KIND_LOSSY = 0,

  /**
   * @generated from enum value: KIND_RELIABLE = 1;
   */
  KIND_RELIABLE = 1,
}

/**
 * Connect to a new LiveKit room
 *
 * @generated from message livekit.proto.ConnectRequest
 */
export declare class ConnectRequest extends Message<ConnectRequest> {
  /**
   * @generated from field: required string url = 1;
   */
  url?: string;

  /**
   * @generated from field: required string token = 2;
   */
  token?: string;

  /**
   * @generated from field: required livekit.proto.RoomOptions options = 3;
   */
  options?: RoomOptions;

  /**
   * @generated from field: optional uint64 request_async_id = 4;
   */
  requestAsyncId?: bigint;

  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 declare class ConnectResponse extends Message<ConnectResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class ConnectCallback extends Message<ConnectCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from oneof livekit.proto.ConnectCallback.message
   */
  message: {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.proto.ConnectCallback.Result result = 3;
     */
    value: ConnectCallback_Result;
    case: "result";
  } | { case: undefined; value?: undefined };

  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 declare class ConnectCallback_ParticipantWithTracks extends Message<ConnectCallback_ParticipantWithTracks> {
  /**
   * @generated from field: required livekit.proto.OwnedParticipant participant = 1;
   */
  participant?: OwnedParticipant;

  /**
   * TrackInfo are not needed here, if we're subscribed to a track, the FfiServer will send
   * a TrackSubscribed event
   *
   * @generated from field: repeated livekit.proto.OwnedTrackPublication publications = 2;
   */
  publications: OwnedTrackPublication[];

  constructor(data?: PartialMessage<ConnectCallback_ParticipantWithTracks>);

  static readonly runtime: typeof 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 declare class ConnectCallback_Result extends Message<ConnectCallback_Result> {
  /**
   * @generated from field: required livekit.proto.OwnedRoom room = 1;
   */
  room?: OwnedRoom;

  /**
   * @generated from field: required livekit.proto.OwnedParticipant local_participant = 2;
   */
  localParticipant?: OwnedParticipant;

  /**
   * @generated from field: repeated livekit.proto.ConnectCallback.ParticipantWithTracks participants = 3;
   */
  participants: ConnectCallback_ParticipantWithTracks[];

  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 declare class DisconnectRequest extends Message<DisconnectRequest> {
  /**
   * @generated from field: required uint64 room_handle = 1;
   */
  roomHandle?: bigint;

  /**
   * @generated from field: optional uint64 request_async_id = 2;
   */
  requestAsyncId?: bigint;

  /**
   * @generated from field: optional livekit.proto.DisconnectReason reason = 3;
   */
  reason?: DisconnectReason;

  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 declare class DisconnectResponse extends Message<DisconnectResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class DisconnectCallback extends Message<DisconnectCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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;
}

/**
 * @generated from message livekit.proto.SimulateScenarioRequest
 */
export declare class SimulateScenarioRequest extends Message<SimulateScenarioRequest> {
  /**
   * @generated from field: required uint64 room_handle = 1;
   */
  roomHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.SimulateScenarioKind scenario = 2;
   */
  scenario?: SimulateScenarioKind;

  /**
   * @generated from field: optional uint64 request_async_id = 3;
   */
  requestAsyncId?: bigint;

  constructor(data?: PartialMessage<SimulateScenarioRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SimulateScenarioRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulateScenarioRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulateScenarioRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulateScenarioRequest;

  static equals(a: SimulateScenarioRequest | PlainMessage<SimulateScenarioRequest> | undefined, b: SimulateScenarioRequest | PlainMessage<SimulateScenarioRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SimulateScenarioResponse
 */
export declare class SimulateScenarioResponse extends Message<SimulateScenarioResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  constructor(data?: PartialMessage<SimulateScenarioResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SimulateScenarioResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulateScenarioResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulateScenarioResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulateScenarioResponse;

  static equals(a: SimulateScenarioResponse | PlainMessage<SimulateScenarioResponse> | undefined, b: SimulateScenarioResponse | PlainMessage<SimulateScenarioResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SimulateScenarioCallback
 */
export declare class SimulateScenarioCallback extends Message<SimulateScenarioCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  error?: string;

  constructor(data?: PartialMessage<SimulateScenarioCallback>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SimulateScenarioCallback";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulateScenarioCallback;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulateScenarioCallback;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulateScenarioCallback;

  static equals(a: SimulateScenarioCallback | PlainMessage<SimulateScenarioCallback> | undefined, b: SimulateScenarioCallback | PlainMessage<SimulateScenarioCallback> | undefined): boolean;
}

/**
 * Publish a track to the room
 *
 * @generated from message livekit.proto.PublishTrackRequest
 */
export declare class PublishTrackRequest extends Message<PublishTrackRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required uint64 track_handle = 2;
   */
  trackHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.TrackPublishOptions options = 3;
   */
  options?: TrackPublishOptions;

  /**
   * @generated from field: optional uint64 request_async_id = 4;
   */
  requestAsyncId?: bigint;

  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 declare class PublishTrackResponse extends Message<PublishTrackResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class PublishTrackCallback extends Message<PublishTrackCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from oneof livekit.proto.PublishTrackCallback.message
   */
  message: {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.proto.OwnedTrackPublication publication = 3;
     */
    value: OwnedTrackPublication;
    case: "publication";
  } | { case: undefined; value?: undefined };

  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;
}

/**
 * @generated from message livekit.proto.ReadyForRoomEventRequest
 */
export declare class ReadyForRoomEventRequest extends Message<ReadyForRoomEventRequest> {
  /**
   * @generated from field: required uint64 room_handle = 1;
   */
  roomHandle?: bigint;

  constructor(data?: PartialMessage<ReadyForRoomEventRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ReadyForRoomEventRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReadyForRoomEventRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReadyForRoomEventRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReadyForRoomEventRequest;

  static equals(a: ReadyForRoomEventRequest | PlainMessage<ReadyForRoomEventRequest> | undefined, b: ReadyForRoomEventRequest | PlainMessage<ReadyForRoomEventRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ReadyForRoomEventResponse
 */
export declare class ReadyForRoomEventResponse extends Message<ReadyForRoomEventResponse> {
  constructor(data?: PartialMessage<ReadyForRoomEventResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ReadyForRoomEventResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReadyForRoomEventResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReadyForRoomEventResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReadyForRoomEventResponse;

  static equals(a: ReadyForRoomEventResponse | PlainMessage<ReadyForRoomEventResponse> | undefined, b: ReadyForRoomEventResponse | PlainMessage<ReadyForRoomEventResponse> | undefined): boolean;
}

/**
 * Unpublish a track from the room
 *
 * @generated from message livekit.proto.UnpublishTrackRequest
 */
export declare class UnpublishTrackRequest extends Message<UnpublishTrackRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string track_sid = 2;
   */
  trackSid?: string;

  /**
   * @generated from field: required bool stop_on_unpublish = 3;
   */
  stopOnUnpublish?: boolean;

  /**
   * @generated from field: optional uint64 request_async_id = 4;
   */
  requestAsyncId?: bigint;

  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 declare class UnpublishTrackResponse extends Message<UnpublishTrackResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class UnpublishTrackCallback extends Message<UnpublishTrackCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class PublishDataRequest extends Message<PublishDataRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required uint64 data_ptr = 2;
   */
  dataPtr?: bigint;

  /**
   * @generated from field: required uint64 data_len = 3;
   */
  dataLen?: bigint;

  /**
   * @generated from field: required bool reliable = 4;
   */
  reliable?: boolean;

  /**
   * @generated from field: repeated string destination_sids = 5 [deprecated = true];
   * @deprecated
   */
  destinationSids: string[];

  /**
   * @generated from field: optional string topic = 6;
   */
  topic?: string;

  /**
   * @generated from field: repeated string destination_identities = 7;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: optional uint64 request_async_id = 8;
   */
  requestAsyncId?: bigint;

  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 declare class PublishDataResponse extends Message<PublishDataResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class PublishDataCallback extends Message<PublishDataCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class PublishTranscriptionRequest extends Message<PublishTranscriptionRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string participant_identity = 2;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string track_id = 3;
   */
  trackId?: string;

  /**
   * @generated from field: repeated livekit.proto.TranscriptionSegment segments = 4;
   */
  segments: TranscriptionSegment[];

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  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 declare class PublishTranscriptionResponse extends Message<PublishTranscriptionResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class PublishTranscriptionCallback extends Message<PublishTranscriptionCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class PublishSipDtmfRequest extends Message<PublishSipDtmfRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required uint32 code = 2;
   */
  code?: number;

  /**
   * @generated from field: required string digit = 3;
   */
  digit?: string;

  /**
   * @generated from field: repeated string destination_identities = 4;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  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 declare class PublishSipDtmfResponse extends Message<PublishSipDtmfResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class PublishSipDtmfCallback extends Message<PublishSipDtmfCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class SetLocalMetadataRequest extends Message<SetLocalMetadataRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string metadata = 2;
   */
  metadata?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 3;
   */
  requestAsyncId?: bigint;

  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 declare class SetLocalMetadataResponse extends Message<SetLocalMetadataResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class SetLocalMetadataCallback extends Message<SetLocalMetadataCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class SendChatMessageRequest extends Message<SendChatMessageRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string message = 2;
   */
  message?: string;

  /**
   * @generated from field: repeated string destination_identities = 3;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: optional string sender_identity = 4;
   */
  senderIdentity?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  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 declare class EditChatMessageRequest extends Message<EditChatMessageRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string edit_text = 2;
   */
  editText?: string;

  /**
   * @generated from field: required livekit.proto.ChatMessage original_message = 3;
   */
  originalMessage?: ChatMessage;

  /**
   * @generated from field: repeated string destination_identities = 4;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: optional string sender_identity = 5;
   */
  senderIdentity?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 6;
   */
  requestAsyncId?: bigint;

  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 declare class SendChatMessageResponse extends Message<SendChatMessageResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class SendChatMessageCallback extends Message<SendChatMessageCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from oneof livekit.proto.SendChatMessageCallback.message
   */
  message: {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.proto.ChatMessage chat_message = 3;
     */
    value: ChatMessage;
    case: "chatMessage";
  } | { case: undefined; value?: undefined };

  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 declare class SetLocalAttributesRequest extends Message<SetLocalAttributesRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: repeated livekit.proto.AttributesEntry attributes = 2;
   */
  attributes: AttributesEntry[];

  /**
   * @generated from field: optional uint64 request_async_id = 3;
   */
  requestAsyncId?: bigint;

  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 declare class AttributesEntry extends Message<AttributesEntry> {
  /**
   * @generated from field: required string key = 1;
   */
  key?: string;

  /**
   * @generated from field: required string value = 2;
   */
  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 declare class SetLocalAttributesResponse extends Message<SetLocalAttributesResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class SetLocalAttributesCallback extends Message<SetLocalAttributesCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class SetLocalNameRequest extends Message<SetLocalNameRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required string name = 2;
   */
  name?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 3;
   */
  requestAsyncId?: bigint;

  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 declare class SetLocalNameResponse extends Message<SetLocalNameResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class SetLocalNameCallback extends Message<SetLocalNameCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  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 declare class SetSubscribedRequest extends Message<SetSubscribedRequest> {
  /**
   * @generated from field: required bool subscribe = 1;
   */
  subscribe?: boolean;

  /**
   * @generated from field: required uint64 publication_handle = 2;
   */
  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 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 declare class GetSessionStatsRequest extends Message<GetSessionStatsRequest> {
  /**
   * @generated from field: required uint64 room_handle = 1;
   */
  roomHandle?: bigint;

  /**
   * @generated from field: optional uint64 request_async_id = 2;
   */
  requestAsyncId?: 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 declare class GetSessionStatsResponse extends Message<GetSessionStatsResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  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 declare class GetSessionStatsCallback extends Message<GetSessionStatsCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from oneof livekit.proto.GetSessionStatsCallback.message
   */
  message: {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.proto.GetSessionStatsCallback.Result result = 3;
     */
    value: GetSessionStatsCallback_Result;
    case: "result";
  } | { case: undefined; value?: undefined };

  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 declare class GetSessionStatsCallback_Result extends Message<GetSessionStatsCallback_Result> {
  /**
   * @generated from field: repeated livekit.proto.RtcStats publisher_stats = 1;
   */
  publisherStats: RtcStats[];

  /**
   * @generated from field: repeated livekit.proto.RtcStats subscriber_stats = 2;
   */
  subscriberStats: RtcStats[];

  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 declare class VideoEncoding extends Message<VideoEncoding> {
  /**
   * @generated from field: required uint64 max_bitrate = 1;
   */
  maxBitrate?: bigint;

  /**
   * @generated from field: required double max_framerate = 2;
   */
  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 declare class AudioEncoding extends Message<AudioEncoding> {
  /**
   * @generated from field: required uint64 max_bitrate = 1;
   */
  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 declare class TrackPublishOptions extends Message<TrackPublishOptions> {
  /**
   * encodings are optional
   *
   * @generated from field: optional livekit.proto.VideoEncoding video_encoding = 1;
   */
  videoEncoding?: VideoEncoding;

  /**
   * @generated from field: optional livekit.proto.AudioEncoding audio_encoding = 2;
   */
  audioEncoding?: AudioEncoding;

  /**
   * @generated from field: optional livekit.proto.VideoCodec video_codec = 3;
   */
  videoCodec?: VideoCodec;

  /**
   * @generated from field: optional bool dtx = 4;
   */
  dtx?: boolean;

  /**
   * @generated from field: optional bool red = 5;
   */
  red?: boolean;

  /**
   * @generated from field: optional bool simulcast = 6;
   */
  simulcast?: boolean;

  /**
   * @generated from field: optional livekit.proto.TrackSource source = 7;
   */
  source?: TrackSource;

  /**
   * @generated from field: optional string stream = 8;
   */
  stream?: string;

  /**
   * @generated from field: optional bool preconnect_buffer = 9;
   */
  preconnectBuffer?: boolean;

  /**
   * @generated from field: repeated livekit.proto.FrameMetadataFeature frame_metadata_features = 10;
   */
  frameMetadataFeatures: FrameMetadataFeature[];

  /**
   * RTP scalability mode (e.g. "L3T3_KEY"). When set, a single RTP
   * encoding is produced with this mode, enabling true SVC for codecs
   * that support it (VP9, AV1). Has no effect for VP8/H264.
   *
   * @generated from field: optional string scalability_mode = 11;
   */
  scalabilityMode?: string;

  /**
   * Preferred encoder backend to use when publishing a video track.
   *
   * @generated from field: optional livekit.proto.VideoEncoderBackend video_encoder = 12;
   */
  videoEncoder?: VideoEncoderBackend;

  /**
   * Controls how the encoder trades off between resolution and framerate
   * when bandwidth is constrained. Default is MAINTAIN_RESOLUTION.
   *
   * @generated from field: optional livekit.proto.DegradationPreference degradation_preference = 13;
   */
  degradationPreference?: DegradationPreference;

  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 declare class IceServer extends Message<IceServer> {
  /**
   * @generated from field: repeated string urls = 1;
   */
  urls: string[];

  /**
   * @generated from field: optional string username = 2;
   */
  username?: string;

  /**
   * @generated from field: optional string password = 3;
   */
  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 declare class RtcConfig extends Message<RtcConfig> {
  /**
   * @generated from field: optional livekit.proto.IceTransportType ice_transport_type = 1;
   */
  iceTransportType?: IceTransportType;

  /**
   * @generated from field: optional livekit.proto.ContinualGatheringPolicy continual_gathering_policy = 2;
   */
  continualGatheringPolicy?: ContinualGatheringPolicy;

  /**
   * empty fallback to default
   *
   * @generated from field: repeated livekit.proto.IceServer ice_servers = 3;
   */
  iceServers: IceServer[];

  constructor(data?: PartialMessage<RtcConfig>);

  static readonly runtime: typeof 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;
}

/**
 * Options controlling data stream behavior for the room.
 *
 * @generated from message livekit.proto.RoomDataStreamOptions
 */
export declare class RoomDataStreamOptions extends Message<RoomDataStreamOptions> {
  /**
   * Maximum decompressed payload size in bytes accepted for a single incoming
   * data stream. Streams exceeding this limit terminate with an error on the
   * receiving side. Unset falls back to the SDK default.
   *
   * @generated from field: optional uint64 max_payload_byte_length = 1;
   */
  maxPayloadByteLength?: bigint;

  /**
   * Temporary migration aid for SDKs that still implement data streams in
   * their own client-side code on top of the FFI instead of using the FFI
   * data stream API. When true, this client does not advertise data streams
   * v2 support: ClientInfo.client_protocol is capped at 1 (DATA_STREAM_RPC),
   * so remote clients will not use v2-only behavior toward this client.
   * Defaults to false (v2 advertised). Will be removed once all FFI
   * consumers migrate.
   *
   * @generated from field: optional bool use_legacy_client_implementation = 2;
   */
  useLegacyClientImplementation?: boolean;

  constructor(data?: PartialMessage<RoomDataStreamOptions>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.RoomDataStreamOptions";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomDataStreamOptions;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RoomDataStreamOptions;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RoomDataStreamOptions;

  static equals(a: RoomDataStreamOptions | PlainMessage<RoomDataStreamOptions> | undefined, b: RoomDataStreamOptions | PlainMessage<RoomDataStreamOptions> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.RoomOptions
 */
export declare class RoomOptions extends Message<RoomOptions> {
  /**
   * @generated from field: optional bool auto_subscribe = 1;
   */
  autoSubscribe?: boolean;

  /**
   * @generated from field: optional bool adaptive_stream = 2;
   */
  adaptiveStream?: boolean;

  /**
   * @generated from field: optional bool dynacast = 3;
   */
  dynacast?: boolean;

  /**
   * @generated from field: optional livekit.proto.E2eeOptions e2ee = 4 [deprecated = true];
   * @deprecated
   */
  e2ee?: E2eeOptions;

  /**
   * allow to setup a custom RtcConfiguration
   *
   * @generated from field: optional livekit.proto.RtcConfig rtc_config = 5;
   */
  rtcConfig?: RtcConfig;

  /**
   * @generated from field: optional uint32 join_retries = 6;
   */
  joinRetries?: number;

  /**
   * @generated from field: optional livekit.proto.E2eeOptions encryption = 7;
   */
  encryption?: E2eeOptions;

  /**
   * use single peer connection for both publish/subscribe (default: false)
   *
   * @generated from field: optional bool single_peer_connection = 8;
   */
  singlePeerConnection?: boolean;

  /**
   * timeout in milliseconds for each signal connection attempt (default: 5000)
   *
   * @generated from field: optional uint64 connect_timeout_ms = 9;
   */
  connectTimeoutMs?: bigint;

  /**
   * data stream behavior for this room
   *
   * @generated from field: optional livekit.proto.RoomDataStreamOptions data_stream = 10;
   */
  dataStream?: RoomDataStreamOptions;

  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 declare class TranscriptionSegment extends Message<TranscriptionSegment> {
  /**
   * @generated from field: required string id = 1;
   */
  id?: string;

  /**
   * @generated from field: required string text = 2;
   */
  text?: string;

  /**
   * @generated from field: required uint64 start_time = 3;
   */
  startTime?: bigint;

  /**
   * @generated from field: required uint64 end_time = 4;
   */
  endTime?: bigint;

  /**
   * @generated from field: required bool final = 5;
   */
  final?: boolean;

  /**
   * @generated from field: required string language = 6;
   */
  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 declare class BufferInfo extends Message<BufferInfo> {
  /**
   * @generated from field: required uint64 data_ptr = 1;
   */
  dataPtr?: bigint;

  /**
   * @generated from field: required uint64 data_len = 2;
   */
  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 declare class OwnedBuffer extends Message<OwnedBuffer> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

  /**
   * @generated from field: required livekit.proto.BufferInfo data = 2;
   */
  data?: BufferInfo;

  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 declare class RoomEvent extends Message<RoomEvent> {
  /**
   * @generated from field: required uint64 room_handle = 1;
   */
  roomHandle?: bigint;

  /**
   * @generated from oneof livekit.proto.RoomEvent.message
   */
  message: {
    /**
     * @generated from field: livekit.proto.ParticipantConnected participant_connected = 2;
     */
    value: ParticipantConnected;
    case: "participantConnected";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantDisconnected participant_disconnected = 3;
     */
    value: ParticipantDisconnected;
    case: "participantDisconnected";
  } | {
    /**
     * @generated from field: livekit.proto.LocalTrackPublished local_track_published = 4;
     */
    value: LocalTrackPublished;
    case: "localTrackPublished";
  } | {
    /**
     * @generated from field: livekit.proto.LocalTrackUnpublished local_track_unpublished = 5;
     */
    value: LocalTrackUnpublished;
    case: "localTrackUnpublished";
  } | {
    /**
     * @generated from field: livekit.proto.LocalTrackSubscribed local_track_subscribed = 6;
     */
    value: LocalTrackSubscribed;
    case: "localTrackSubscribed";
  } | {
    /**
     * @generated from field: livekit.proto.TrackPublished track_published = 7;
     */
    value: TrackPublished;
    case: "trackPublished";
  } | {
    /**
     * @generated from field: livekit.proto.TrackUnpublished track_unpublished = 8;
     */
    value: TrackUnpublished;
    case: "trackUnpublished";
  } | {
    /**
     * @generated from field: livekit.proto.TrackSubscribed track_subscribed = 9;
     */
    value: TrackSubscribed;
    case: "trackSubscribed";
  } | {
    /**
     * @generated from field: livekit.proto.TrackUnsubscribed track_unsubscribed = 10;
     */
    value: TrackUnsubscribed;
    case: "trackUnsubscribed";
  } | {
    /**
     * @generated from field: livekit.proto.TrackSubscriptionFailed track_subscription_failed = 11;
     */
    value: TrackSubscriptionFailed;
    case: "trackSubscriptionFailed";
  } | {
    /**
     * @generated from field: livekit.proto.TrackMuted track_muted = 12;
     */
    value: TrackMuted;
    case: "trackMuted";
  } | {
    /**
     * @generated from field: livekit.proto.TrackUnmuted track_unmuted = 13;
     */
    value: TrackUnmuted;
    case: "trackUnmuted";
  } | {
    /**
     * @generated from field: livekit.proto.ActiveSpeakersChanged active_speakers_changed = 14;
     */
    value: ActiveSpeakersChanged;
    case: "activeSpeakersChanged";
  } | {
    /**
     * @generated from field: livekit.proto.RoomMetadataChanged room_metadata_changed = 15;
     */
    value: RoomMetadataChanged;
    case: "roomMetadataChanged";
  } | {
    /**
     * @generated from field: livekit.proto.RoomSidChanged room_sid_changed = 16;
     */
    value: RoomSidChanged;
    case: "roomSidChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantMetadataChanged participant_metadata_changed = 17;
     */
    value: ParticipantMetadataChanged;
    case: "participantMetadataChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantNameChanged participant_name_changed = 18;
     */
    value: ParticipantNameChanged;
    case: "participantNameChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantAttributesChanged participant_attributes_changed = 19;
     */
    value: ParticipantAttributesChanged;
    case: "participantAttributesChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ConnectionQualityChanged connection_quality_changed = 20;
     */
    value: ConnectionQualityChanged;
    case: "connectionQualityChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ConnectionStateChanged connection_state_changed = 21;
     */
    value: ConnectionStateChanged;
    case: "connectionStateChanged";
  } | {
    /**
     * Connected connected = 21;
     *
     * @generated from field: livekit.proto.Disconnected disconnected = 22;
     */
    value: Disconnected;
    case: "disconnected";
  } | {
    /**
     * @generated from field: livekit.proto.Reconnecting reconnecting = 23;
     */
    value: Reconnecting;
    case: "reconnecting";
  } | {
    /**
     * @generated from field: livekit.proto.Reconnected reconnected = 24;
     */
    value: Reconnected;
    case: "reconnected";
  } | {
    /**
     * @generated from field: livekit.proto.E2eeStateChanged e2ee_state_changed = 25;
     */
    value: E2eeStateChanged;
    case: "e2eeStateChanged";
  } | {
    /**
     * The stream of room events has ended
     *
     * @generated from field: livekit.proto.RoomEOS eos = 26;
     */
    value: RoomEOS;
    case: "eos";
  } | {
    /**
     * @generated from field: livekit.proto.DataPacketReceived data_packet_received = 27;
     */
    value: DataPacketReceived;
    case: "dataPacketReceived";
  } | {
    /**
     * @generated from field: livekit.proto.TranscriptionReceived transcription_received = 28;
     */
    value: TranscriptionReceived;
    case: "transcriptionReceived";
  } | {
    /**
     * @generated from field: livekit.proto.ChatMessageReceived chat_message = 29;
     */
    value: ChatMessageReceived;
    case: "chatMessage";
  } | {
    /**
     * Data stream (low level)
     *
     * @generated from field: livekit.proto.DataStreamHeaderReceived stream_header_received = 30;
     */
    value: DataStreamHeaderReceived;
    case: "streamHeaderReceived";
  } | {
    /**
     * @generated from field: livekit.proto.DataStreamChunkReceived stream_chunk_received = 31;
     */
    value: DataStreamChunkReceived;
    case: "streamChunkReceived";
  } | {
    /**
     * @generated from field: livekit.proto.DataStreamTrailerReceived stream_trailer_received = 32;
     */
    value: DataStreamTrailerReceived;
    case: "streamTrailerReceived";
  } | {
    /**
     * @generated from field: livekit.proto.DataChannelBufferedAmountLowThresholdChanged data_channel_low_threshold_changed = 33;
     */
    value: DataChannelBufferedAmountLowThresholdChanged;
    case: "dataChannelLowThresholdChanged";
  } | {
    /**
     * Data stream (high level)
     *
     * @generated from field: livekit.proto.ByteStreamOpened byte_stream_opened = 34;
     */
    value: ByteStreamOpened;
    case: "byteStreamOpened";
  } | {
    /**
     * @generated from field: livekit.proto.TextStreamOpened text_stream_opened = 35;
     */
    value: TextStreamOpened;
    case: "textStreamOpened";
  } | {
    /**
     * Room info updated
     *
     * @generated from field: livekit.proto.RoomInfo room_updated = 36;
     */
    value: RoomInfo;
    case: "roomUpdated";
  } | {
    /**
     * Participant moved to new room
     *
     * @generated from field: livekit.proto.RoomInfo moved = 37;
     */
    value: RoomInfo;
    case: "moved";
  } | {
    /**
     * carry over all participant info updates, including sid
     *
     * @generated from field: livekit.proto.ParticipantsUpdated participants_updated = 38;
     */
    value: ParticipantsUpdated;
    case: "participantsUpdated";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantEncryptionStatusChanged participant_encryption_status_changed = 39;
     */
    value: ParticipantEncryptionStatusChanged;
    case: "participantEncryptionStatusChanged";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantPermissionChanged participant_permission_changed = 41;
     */
    value: ParticipantPermissionChanged;
    case: "participantPermissionChanged";
  } | {
    /**
     * @generated from field: livekit.proto.TokenRefreshed token_refreshed = 40;
     */
    value: TokenRefreshed;
    case: "tokenRefreshed";
  } | {
    /**
     * @generated from field: livekit.proto.ParticipantActive participant_active = 42;
     */
    value: ParticipantActive;
    case: "participantActive";
  } | {
    /**
     * @generated from field: livekit.proto.DataTrackPublished data_track_published = 43;
     */
    value: DataTrackPublished;
    case: "dataTrackPublished";
  } | {
    /**
     * @generated from field: livekit.proto.DataTrackUnpublished data_track_unpublished = 44;
     */
    value: DataTrackUnpublished;
    case: "dataTrackUnpublished";
  } | {
    /**
     * @generated from field: livekit.proto.LocalTrackRepublished local_track_republished = 45;
     */
    value: LocalTrackRepublished;
    case: "localTrackRepublished";
  } | { case: undefined; value?: undefined };

  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 declare class RoomInfo extends Message<RoomInfo> {
  /**
   * @generated from field: optional string sid = 1;
   */
  sid?: string;

  /**
   * @generated from field: required string name = 2;
   */
  name?: string;

  /**
   * @generated from field: required string metadata = 3;
   */
  metadata?: string;

  /**
   * @generated from field: required uint64 lossy_dc_buffered_amount_low_threshold = 4;
   */
  lossyDcBufferedAmountLowThreshold?: bigint;

  /**
   * @generated from field: required uint64 reliable_dc_buffered_amount_low_threshold = 5;
   */
  reliableDcBufferedAmountLowThreshold?: bigint;

  /**
   * @generated from field: required uint32 empty_timeout = 6;
   */
  emptyTimeout?: number;

  /**
   * @generated from field: required uint32 departure_timeout = 7;
   */
  departureTimeout?: number;

  /**
   * @generated from field: required uint32 max_participants = 8;
   */
  maxParticipants?: number;

  /**
   * @generated from field: required int64 creation_time = 9;
   */
  creationTime?: bigint;

  /**
   * @generated from field: required uint32 num_participants = 10;
   */
  numParticipants?: number;

  /**
   * @generated from field: required uint32 num_publishers = 11;
   */
  numPublishers?: number;

  /**
   * @generated from field: required bool active_recording = 12;
   */
  activeRecording?: boolean;

  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 declare class OwnedRoom extends Message<OwnedRoom> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

  /**
   * @generated from field: required livekit.proto.RoomInfo info = 2;
   */
  info?: RoomInfo;

  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.ParticipantsUpdated
 */
export declare class ParticipantsUpdated extends Message<ParticipantsUpdated> {
  /**
   * @generated from field: repeated livekit.proto.ParticipantInfo participants = 1;
   */
  participants: ParticipantInfo[];

  constructor(data?: PartialMessage<ParticipantsUpdated>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ParticipantsUpdated";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantsUpdated;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantsUpdated;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantsUpdated;

  static equals(a: ParticipantsUpdated | PlainMessage<ParticipantsUpdated> | undefined, b: ParticipantsUpdated | PlainMessage<ParticipantsUpdated> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ParticipantConnected
 */
export declare class ParticipantConnected extends Message<ParticipantConnected> {
  /**
   * @generated from field: required livekit.proto.OwnedParticipant info = 1;
   */
  info?: OwnedParticipant;

  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.ParticipantActive
 */
export declare class ParticipantActive extends Message<ParticipantActive> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  constructor(data?: PartialMessage<ParticipantActive>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ParticipantActive";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantActive;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantActive;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantActive;

  static equals(a: ParticipantActive | PlainMessage<ParticipantActive> | undefined, b: ParticipantActive | PlainMessage<ParticipantActive> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ParticipantDisconnected
 */
export declare class ParticipantDisconnected extends Message<ParticipantDisconnected> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.DisconnectReason disconnect_reason = 2;
   */
  disconnectReason?: DisconnectReason;

  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 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;

  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 declare class LocalTrackUnpublished extends Message<LocalTrackUnpublished> {
  /**
   * @generated from field: required string publication_sid = 1;
   */
  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;
}

/**
 * Fired when the SDK auto-republishes a local track during a full
 * reconnect. The FfiPublication handle is preserved across the cycle —
 * language bindings should look up the existing publication object by
 * `previous_sid` (its old SID), update its TrackPublicationInfo in place
 * with `info`, and rekey it under the new SID. Apps holding a cached
 * reference to the publication continue to see a valid object whose
 * reads/writes hit current state.
 *
 * @generated from message livekit.proto.LocalTrackRepublished
 */
export declare class LocalTrackRepublished extends Message<LocalTrackRepublished> {
  /**
   * @generated from field: required uint64 publication_handle = 1;
   */
  publicationHandle?: bigint;

  /**
   * @generated from field: required string previous_sid = 2;
   */
  previousSid?: string;

  /**
   * @generated from field: required livekit.proto.TrackPublicationInfo info = 3;
   */
  info?: TrackPublicationInfo;

  constructor(data?: PartialMessage<LocalTrackRepublished>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.LocalTrackRepublished";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LocalTrackRepublished;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LocalTrackRepublished;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LocalTrackRepublished;

  static equals(a: LocalTrackRepublished | PlainMessage<LocalTrackRepublished> | undefined, b: LocalTrackRepublished | PlainMessage<LocalTrackRepublished> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.LocalTrackSubscribed
 */
export declare class LocalTrackSubscribed extends Message<LocalTrackSubscribed> {
  /**
   * @generated from field: required string track_sid = 2;
   */
  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 declare class TrackPublished extends Message<TrackPublished> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.OwnedTrackPublication publication = 2;
   */
  publication?: OwnedTrackPublication;

  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 declare class TrackUnpublished extends Message<TrackUnpublished> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string publication_sid = 2;
   */
  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 declare class TrackSubscribed extends Message<TrackSubscribed> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.OwnedTrack track = 2;
   */
  track?: OwnedTrack;

  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 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;

  /**
   * @generated from field: required string track_sid = 2;
   */
  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 declare class TrackSubscriptionFailed extends Message<TrackSubscriptionFailed> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string track_sid = 2;
   */
  trackSid?: string;

  /**
   * @generated from field: required string error = 3;
   */
  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 declare class TrackMuted extends Message<TrackMuted> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string track_sid = 2;
   */
  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 declare class TrackUnmuted extends Message<TrackUnmuted> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string track_sid = 2;
   */
  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 declare class E2eeStateChanged extends Message<E2eeStateChanged> {
  /**
   * Using sid instead of identity for ffi communication
   *
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.EncryptionState state = 2;
   */
  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 declare class ActiveSpeakersChanged extends Message<ActiveSpeakersChanged> {
  /**
   * @generated from field: repeated string participant_identities = 1;
   */
  participantIdentities: string[];

  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 declare class RoomMetadataChanged extends Message<RoomMetadataChanged> {
  /**
   * @generated from field: required string metadata = 1;
   */
  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 declare class RoomSidChanged extends Message<RoomSidChanged> {
  /**
   * @generated from field: required string sid = 1;
   */
  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 declare class ParticipantMetadataChanged extends Message<ParticipantMetadataChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string metadata = 2;
   */
  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 declare class ParticipantAttributesChanged extends Message<ParticipantAttributesChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: repeated livekit.proto.AttributesEntry attributes = 2;
   */
  attributes: AttributesEntry[];

  /**
   * @generated from field: repeated livekit.proto.AttributesEntry changed_attributes = 3;
   */
  changedAttributes: AttributesEntry[];

  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.ParticipantEncryptionStatusChanged
 */
export declare class ParticipantEncryptionStatusChanged extends Message<ParticipantEncryptionStatusChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required bool is_encrypted = 2;
   */
  isEncrypted?: boolean;

  constructor(data?: PartialMessage<ParticipantEncryptionStatusChanged>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ParticipantEncryptionStatusChanged";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantEncryptionStatusChanged;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantEncryptionStatusChanged;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantEncryptionStatusChanged;

  static equals(a: ParticipantEncryptionStatusChanged | PlainMessage<ParticipantEncryptionStatusChanged> | undefined, b: ParticipantEncryptionStatusChanged | PlainMessage<ParticipantEncryptionStatusChanged> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ParticipantNameChanged
 */
export declare class ParticipantNameChanged extends Message<ParticipantNameChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required string name = 2;
   */
  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.ParticipantPermissionChanged
 */
export declare class ParticipantPermissionChanged extends Message<ParticipantPermissionChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: optional livekit.proto.ParticipantPermission permission = 2;
   */
  permission?: ParticipantPermission;

  constructor(data?: PartialMessage<ParticipantPermissionChanged>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ParticipantPermissionChanged";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantPermissionChanged;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantPermissionChanged;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantPermissionChanged;

  static equals(a: ParticipantPermissionChanged | PlainMessage<ParticipantPermissionChanged> | undefined, b: ParticipantPermissionChanged | PlainMessage<ParticipantPermissionChanged> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ConnectionQualityChanged
 */
export declare class ConnectionQualityChanged extends Message<ConnectionQualityChanged> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.ConnectionQuality quality = 2;
   */
  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 declare class UserPacket extends Message<UserPacket> {
  /**
   * @generated from field: required livekit.proto.OwnedBuffer data = 1;
   */
  data?: OwnedBuffer;

  /**
   * @generated from field: optional string topic = 2;
   */
  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 declare class ChatMessage extends Message<ChatMessage> {
  /**
   * @generated from field: required string id = 1;
   */
  id?: string;

  /**
   * @generated from field: required int64 timestamp = 2;
   */
  timestamp?: bigint;

  /**
   * @generated from field: required string message = 3;
   */
  message?: string;

  /**
   * @generated from field: optional int64 edit_timestamp = 4;
   */
  editTimestamp?: bigint;

  /**
   * @generated from field: optional bool deleted = 5;
   */
  deleted?: boolean;

  /**
   * @generated from field: optional bool generated = 6;
   */
  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 declare class ChatMessageReceived extends Message<ChatMessageReceived> {
  /**
   * @generated from field: required livekit.proto.ChatMessage message = 1;
   */
  message?: ChatMessage;

  /**
   * @generated from field: required string participant_identity = 2;
   */
  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 declare class SipDTMF extends Message<SipDTMF> {
  /**
   * @generated from field: required uint32 code = 1;
   */
  code?: number;

  /**
   * @generated from field: optional string digit = 2;
   */
  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 declare class DataPacketReceived extends Message<DataPacketReceived> {
  /**
   * @generated from field: required livekit.proto.DataPacketKind kind = 1;
   */
  kind?: DataPacketKind;

  /**
   * Can be empty if the data is sent a server SDK
   *
   * @generated from field: required string participant_identity = 2;
   */
  participantIdentity?: string;

  /**
   * @generated from oneof livekit.proto.DataPacketReceived.value
   */
  value: {
    /**
     * @generated from field: livekit.proto.UserPacket user = 4;
     */
    value: UserPacket;
    case: "user";
  } | {
    /**
     * @generated from field: livekit.proto.SipDTMF sip_dtmf = 5;
     */
    value: SipDTMF;
    case: "sipDtmf";
  } | { case: undefined; value?: undefined };

  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 declare class TranscriptionReceived extends Message<TranscriptionReceived> {
  /**
   * @generated from field: optional string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: optional string track_sid = 2;
   */
  trackSid?: string;

  /**
   * @generated from field: repeated livekit.proto.TranscriptionSegment segments = 3;
   */
  segments: TranscriptionSegment[];

  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 declare class ConnectionStateChanged extends Message<ConnectionStateChanged> {
  /**
   * @generated from field: required livekit.proto.ConnectionState state = 1;
   */
  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 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 declare class Disconnected extends Message<Disconnected> {
  /**
   * @generated from field: required livekit.proto.DisconnectReason reason = 1;
   */
  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 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 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.TokenRefreshed
 */
export declare class TokenRefreshed extends Message<TokenRefreshed> {
  /**
   * @generated from field: required string token = 1;
   */
  token?: string;

  constructor(data?: PartialMessage<TokenRefreshed>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.TokenRefreshed";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenRefreshed;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenRefreshed;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenRefreshed;

  static equals(a: TokenRefreshed | PlainMessage<TokenRefreshed> | undefined, b: TokenRefreshed | PlainMessage<TokenRefreshed> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.RoomEOS
 */
export 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;
}

/**
 * @generated from message livekit.proto.DataStream
 */
export 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;
}

/**
 * enum for operation types (specific to TextHeader)
 *
 * @generated from enum livekit.proto.DataStream.OperationType
 */
export declare enum DataStream_OperationType {
  /**
   * @generated from enum value: CREATE = 0;
   */
  CREATE = 0,

  /**
   * @generated from enum value: UPDATE = 1;
   */
  UPDATE = 1,

  /**
   * @generated from enum value: DELETE = 2;
   */
  DELETE = 2,

  /**
   * @generated from enum value: REACTION = 3;
   */
  REACTION = 3,
}

/**
 * header properties specific to text streams
 *
 * @generated from message livekit.proto.DataStream.TextHeader
 */
export declare class DataStream_TextHeader extends Message<DataStream_TextHeader> {
  /**
   * @generated from field: required livekit.proto.DataStream.OperationType operation_type = 1;
   */
  operationType?: DataStream_OperationType;

  /**
   * Optional: Version for updates/edits
   *
   * @generated from field: optional int32 version = 2;
   */
  version?: number;

  /**
   * Optional: Reply to specific message
   *
   * @generated from field: optional string reply_to_stream_id = 3;
   */
  replyToStreamId?: string;

  /**
   * file attachments for text streams
   *
   * @generated from field: repeated string attached_stream_ids = 4;
   */
  attachedStreamIds: string[];

  /**
   * true if the text has been generated by an agent from a participant's audio transcription
   *
   * @generated from field: optional 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;
}

/**
 * header properties specific to byte or file streams
 *
 * @generated from message livekit.proto.DataStream.ByteHeader
 */
export declare class DataStream_ByteHeader extends Message<DataStream_ByteHeader> {
  /**
   * @generated from field: required string name = 1;
   */
  name?: string;

  constructor(data?: PartialMessage<DataStream_ByteHeader>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataStream.ByteHeader";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_ByteHeader;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_ByteHeader;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_ByteHeader;

  static equals(a: DataStream_ByteHeader | PlainMessage<DataStream_ByteHeader> | undefined, b: DataStream_ByteHeader | PlainMessage<DataStream_ByteHeader> | undefined): boolean;
}

/**
 * main DataStream.Header that contains a oneof for specific headers
 *
 * @generated from message livekit.proto.DataStream.Header
 */
export declare class DataStream_Header extends Message<DataStream_Header> {
  /**
   * unique identifier for this data stream
   *
   * @generated from field: required string stream_id = 1;
   */
  streamId?: string;

  /**
   * using int64 for Unix timestamp
   *
   * @generated from field: required int64 timestamp = 2;
   */
  timestamp?: bigint;

  /**
   * @generated from field: required string mime_type = 3;
   */
  mimeType?: string;

  /**
   * @generated from field: required string topic = 4;
   */
  topic?: string;

  /**
   * only populated for finite streams, if it's a stream of unknown size this stays empty
   *
   * @generated from field: optional uint64 total_length = 5;
   */
  totalLength?: bigint;

  /**
   * user defined attributes map that can carry additional info
   *
   * @generated from field: map<string, string> attributes = 6;
   */
  attributes: { [key: string]: string };

  /**
   * oneof to choose between specific header types
   *
   * @generated from oneof livekit.proto.DataStream.Header.content_header
   */
  contentHeader: {
    /**
     * @generated from field: livekit.proto.DataStream.TextHeader text_header = 7;
     */
    value: DataStream_TextHeader;
    case: "textHeader";
  } | {
    /**
     * @generated from field: livekit.proto.DataStream.ByteHeader byte_header = 8;
     */
    value: DataStream_ByteHeader;
    case: "byteHeader";
  } | { 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
 */
export declare class DataStream_Chunk extends Message<DataStream_Chunk> {
  /**
   * unique identifier for this data stream to map it to the correct header
   *
   * @generated from field: required string stream_id = 1;
   */
  streamId?: string;

  /**
   * @generated from field: required uint64 chunk_index = 2;
   */
  chunkIndex?: bigint;

  /**
   * content as binary (bytes)
   *
   * @generated from field: required bytes content = 3;
   */
  content?: Uint8Array;

  /**
   * a version indicating that this chunk_index has been retroactively modified and the original one needs to be replaced
   *
   * @generated from field: optional int32 version = 4;
   */
  version?: number;

  /**
   * optional, initialization vector for AES-GCM encryption
   *
   * @generated from field: optional bytes iv = 5;
   */
  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;
}

/**
 * @generated from message livekit.proto.DataStream.Trailer
 */
export declare class DataStream_Trailer extends Message<DataStream_Trailer> {
  /**
   * unique identifier for this data stream
   *
   * @generated from field: required string stream_id = 1;
   */
  streamId?: string;

  /**
   * reason why the stream was closed (could contain "error" / "interrupted" / empty for expected end)
   *
   * @generated from field: required string reason = 2;
   */
  reason?: string;

  /**
   * finalizing updates for the stream, can also include additional insights for errors or endTime for transcription
   *
   * @generated from field: map<string, string> attributes = 3;
   */
  attributes: { [key: string]: string };

  constructor(data?: PartialMessage<DataStream_Trailer>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataStream.Trailer";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Trailer;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_Trailer;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_Trailer;

  static equals(a: DataStream_Trailer | PlainMessage<DataStream_Trailer> | undefined, b: DataStream_Trailer | PlainMessage<DataStream_Trailer> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.DataStreamHeaderReceived
 */
export declare class DataStreamHeaderReceived extends Message<DataStreamHeaderReceived> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.DataStream.Header header = 2;
   */
  header?: DataStream_Header;

  constructor(data?: PartialMessage<DataStreamHeaderReceived>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataStreamHeaderReceived";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamHeaderReceived;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamHeaderReceived;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamHeaderReceived;

  static equals(a: DataStreamHeaderReceived | PlainMessage<DataStreamHeaderReceived> | undefined, b: DataStreamHeaderReceived | PlainMessage<DataStreamHeaderReceived> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.DataStreamChunkReceived
 */
export declare class DataStreamChunkReceived extends Message<DataStreamChunkReceived> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.DataStream.Chunk chunk = 2;
   */
  chunk?: DataStream_Chunk;

  constructor(data?: PartialMessage<DataStreamChunkReceived>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataStreamChunkReceived";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamChunkReceived;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamChunkReceived;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamChunkReceived;

  static equals(a: DataStreamChunkReceived | PlainMessage<DataStreamChunkReceived> | undefined, b: DataStreamChunkReceived | PlainMessage<DataStreamChunkReceived> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.DataStreamTrailerReceived
 */
export declare class DataStreamTrailerReceived extends Message<DataStreamTrailerReceived> {
  /**
   * @generated from field: required string participant_identity = 1;
   */
  participantIdentity?: string;

  /**
   * @generated from field: required livekit.proto.DataStream.Trailer trailer = 2;
   */
  trailer?: DataStream_Trailer;

  constructor(data?: PartialMessage<DataStreamTrailerReceived>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataStreamTrailerReceived";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamTrailerReceived;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamTrailerReceived;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamTrailerReceived;

  static equals(a: DataStreamTrailerReceived | PlainMessage<DataStreamTrailerReceived> | undefined, b: DataStreamTrailerReceived | PlainMessage<DataStreamTrailerReceived> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamHeaderRequest
 */
export declare class SendStreamHeaderRequest extends Message<SendStreamHeaderRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.DataStream.Header header = 2;
   */
  header?: DataStream_Header;

  /**
   * @generated from field: repeated string destination_identities = 3;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: required string sender_identity = 4;
   */
  senderIdentity?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamHeaderRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamHeaderRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderRequest;

  static equals(a: SendStreamHeaderRequest | PlainMessage<SendStreamHeaderRequest> | undefined, b: SendStreamHeaderRequest | PlainMessage<SendStreamHeaderRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamChunkRequest
 */
export declare class SendStreamChunkRequest extends Message<SendStreamChunkRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.DataStream.Chunk chunk = 2;
   */
  chunk?: DataStream_Chunk;

  /**
   * @generated from field: repeated string destination_identities = 3;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: required string sender_identity = 4;
   */
  senderIdentity?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamChunkRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamChunkRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkRequest;

  static equals(a: SendStreamChunkRequest | PlainMessage<SendStreamChunkRequest> | undefined, b: SendStreamChunkRequest | PlainMessage<SendStreamChunkRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamTrailerRequest
 */
export declare class SendStreamTrailerRequest extends Message<SendStreamTrailerRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.DataStream.Trailer trailer = 2;
   */
  trailer?: DataStream_Trailer;

  /**
   * @generated from field: repeated string destination_identities = 3;
   */
  destinationIdentities: string[];

  /**
   * @generated from field: required string sender_identity = 4;
   */
  senderIdentity?: string;

  /**
   * @generated from field: optional uint64 request_async_id = 5;
   */
  requestAsyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamTrailerRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamTrailerRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerRequest;

  static equals(a: SendStreamTrailerRequest | PlainMessage<SendStreamTrailerRequest> | undefined, b: SendStreamTrailerRequest | PlainMessage<SendStreamTrailerRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamHeaderResponse
 */
export declare class SendStreamHeaderResponse extends Message<SendStreamHeaderResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamHeaderResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamHeaderResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderResponse;

  static equals(a: SendStreamHeaderResponse | PlainMessage<SendStreamHeaderResponse> | undefined, b: SendStreamHeaderResponse | PlainMessage<SendStreamHeaderResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamChunkResponse
 */
export declare class SendStreamChunkResponse extends Message<SendStreamChunkResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamChunkResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamChunkResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkResponse;

  static equals(a: SendStreamChunkResponse | PlainMessage<SendStreamChunkResponse> | undefined, b: SendStreamChunkResponse | PlainMessage<SendStreamChunkResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamTrailerResponse
 */
export declare class SendStreamTrailerResponse extends Message<SendStreamTrailerResponse> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  constructor(data?: PartialMessage<SendStreamTrailerResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamTrailerResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerResponse;

  static equals(a: SendStreamTrailerResponse | PlainMessage<SendStreamTrailerResponse> | undefined, b: SendStreamTrailerResponse | PlainMessage<SendStreamTrailerResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamHeaderCallback
 */
export declare class SendStreamHeaderCallback extends Message<SendStreamHeaderCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  error?: string;

  constructor(data?: PartialMessage<SendStreamHeaderCallback>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamHeaderCallback";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderCallback;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderCallback;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderCallback;

  static equals(a: SendStreamHeaderCallback | PlainMessage<SendStreamHeaderCallback> | undefined, b: SendStreamHeaderCallback | PlainMessage<SendStreamHeaderCallback> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamChunkCallback
 */
export declare class SendStreamChunkCallback extends Message<SendStreamChunkCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  error?: string;

  constructor(data?: PartialMessage<SendStreamChunkCallback>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamChunkCallback";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkCallback;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkCallback;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkCallback;

  static equals(a: SendStreamChunkCallback | PlainMessage<SendStreamChunkCallback> | undefined, b: SendStreamChunkCallback | PlainMessage<SendStreamChunkCallback> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SendStreamTrailerCallback
 */
export declare class SendStreamTrailerCallback extends Message<SendStreamTrailerCallback> {
  /**
   * @generated from field: required uint64 async_id = 1;
   */
  asyncId?: bigint;

  /**
   * @generated from field: optional string error = 2;
   */
  error?: string;

  constructor(data?: PartialMessage<SendStreamTrailerCallback>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SendStreamTrailerCallback";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerCallback;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerCallback;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerCallback;

  static equals(a: SendStreamTrailerCallback | PlainMessage<SendStreamTrailerCallback> | undefined, b: SendStreamTrailerCallback | PlainMessage<SendStreamTrailerCallback> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SetDataChannelBufferedAmountLowThresholdRequest
 */
export declare class SetDataChannelBufferedAmountLowThresholdRequest extends Message<SetDataChannelBufferedAmountLowThresholdRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required uint64 threshold = 2;
   */
  threshold?: bigint;

  /**
   * @generated from field: required livekit.proto.DataPacketKind kind = 3;
   */
  kind?: DataPacketKind;

  constructor(data?: PartialMessage<SetDataChannelBufferedAmountLowThresholdRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SetDataChannelBufferedAmountLowThresholdRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest;

  static equals(a: SetDataChannelBufferedAmountLowThresholdRequest | PlainMessage<SetDataChannelBufferedAmountLowThresholdRequest> | undefined, b: SetDataChannelBufferedAmountLowThresholdRequest | PlainMessage<SetDataChannelBufferedAmountLowThresholdRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.SetDataChannelBufferedAmountLowThresholdResponse
 */
export declare class SetDataChannelBufferedAmountLowThresholdResponse extends Message<SetDataChannelBufferedAmountLowThresholdResponse> {
  constructor(data?: PartialMessage<SetDataChannelBufferedAmountLowThresholdResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.SetDataChannelBufferedAmountLowThresholdResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse;

  static equals(a: SetDataChannelBufferedAmountLowThresholdResponse | PlainMessage<SetDataChannelBufferedAmountLowThresholdResponse> | undefined, b: SetDataChannelBufferedAmountLowThresholdResponse | PlainMessage<SetDataChannelBufferedAmountLowThresholdResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.DataChannelBufferedAmountLowThresholdChanged
 */
export declare class DataChannelBufferedAmountLowThresholdChanged extends Message<DataChannelBufferedAmountLowThresholdChanged> {
  /**
   * @generated from field: required livekit.proto.DataPacketKind kind = 1;
   */
  kind?: DataPacketKind;

  /**
   * @generated from field: required uint64 threshold = 2;
   */
  threshold?: bigint;

  constructor(data?: PartialMessage<DataChannelBufferedAmountLowThresholdChanged>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataChannelBufferedAmountLowThresholdChanged";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataChannelBufferedAmountLowThresholdChanged;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataChannelBufferedAmountLowThresholdChanged;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataChannelBufferedAmountLowThresholdChanged;

  static equals(a: DataChannelBufferedAmountLowThresholdChanged | PlainMessage<DataChannelBufferedAmountLowThresholdChanged> | undefined, b: DataChannelBufferedAmountLowThresholdChanged | PlainMessage<DataChannelBufferedAmountLowThresholdChanged> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.ByteStreamOpened
 */
export declare class ByteStreamOpened extends Message<ByteStreamOpened> {
  /**
   * @generated from field: required livekit.proto.OwnedByteStreamReader reader = 1;
   */
  reader?: OwnedByteStreamReader;

  /**
   * @generated from field: required string participant_identity = 2;
   */
  participantIdentity?: string;

  constructor(data?: PartialMessage<ByteStreamOpened>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.ByteStreamOpened";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ByteStreamOpened;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ByteStreamOpened;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ByteStreamOpened;

  static equals(a: ByteStreamOpened | PlainMessage<ByteStreamOpened> | undefined, b: ByteStreamOpened | PlainMessage<ByteStreamOpened> | undefined): boolean;
}

/**
 * @generated from message livekit.proto.TextStreamOpened
 */
export declare class TextStreamOpened extends Message<TextStreamOpened> {
  /**
   * @generated from field: required livekit.proto.OwnedTextStreamReader reader = 1;
   */
  reader?: OwnedTextStreamReader;

  /**
   * @generated from field: required string participant_identity = 2;
   */
  participantIdentity?: string;

  constructor(data?: PartialMessage<TextStreamOpened>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.TextStreamOpened";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TextStreamOpened;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TextStreamOpened;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TextStreamOpened;

  static equals(a: TextStreamOpened | PlainMessage<TextStreamOpened> | undefined, b: TextStreamOpened | PlainMessage<TextStreamOpened> | undefined): boolean;
}

/**
 * A remote participant published a data track.
 *
 * @generated from message livekit.proto.DataTrackPublished
 */
export declare class DataTrackPublished extends Message<DataTrackPublished> {
  /**
   * @generated from field: required livekit.proto.OwnedRemoteDataTrack track = 1;
   */
  track?: OwnedRemoteDataTrack;

  constructor(data?: PartialMessage<DataTrackPublished>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataTrackPublished";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataTrackPublished;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataTrackPublished;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataTrackPublished;

  static equals(a: DataTrackPublished | PlainMessage<DataTrackPublished> | undefined, b: DataTrackPublished | PlainMessage<DataTrackPublished> | undefined): boolean;
}

/**
 * A remote participant unpublished a data track.
 *
 * @generated from message livekit.proto.DataTrackUnpublished
 */
export declare class DataTrackUnpublished extends Message<DataTrackUnpublished> {
  /**
   * SID of the track that was unpublished.
   *
   * @generated from field: required string sid = 1;
   */
  sid?: string;

  constructor(data?: PartialMessage<DataTrackUnpublished>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.DataTrackUnpublished";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataTrackUnpublished;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataTrackUnpublished;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataTrackUnpublished;

  static equals(a: DataTrackUnpublished | PlainMessage<DataTrackUnpublished> | undefined, b: DataTrackUnpublished | PlainMessage<DataTrackUnpublished> | undefined): boolean;
}