// 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 audio_frame.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 { TrackSource } from "./track_pb.js";
import type { FfiOwnedHandle } from "./handle_pb.js";

/**
 * @generated from enum livekit.proto.SoxResamplerDataType
 */
export declare enum SoxResamplerDataType {
  /**
   * TODO(theomonnom): support other datatypes (shouldn't really be needed)
   *
   * @generated from enum value: SOXR_DATATYPE_INT16I = 0;
   */
  SOXR_DATATYPE_INT16I = 0,

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

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

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

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

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

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

/**
 * @generated from enum livekit.proto.SoxFlagBits
 */
export declare enum SoxFlagBits {
  /**
   * 1 << 0
   *
   * @generated from enum value: SOXR_ROLLOFF_SMALL = 0;
   */
  SOXR_ROLLOFF_SMALL = 0,

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

  /**
   * 1 << 2
   *
   * @generated from enum value: SOXR_ROLLOFF_NONE = 2;
   */
  SOXR_ROLLOFF_NONE = 2,

  /**
   * 1 << 3
   *
   * @generated from enum value: SOXR_HIGH_PREC_CLOCK = 3;
   */
  SOXR_HIGH_PREC_CLOCK = 3,

  /**
   * 1 << 4
   *
   * @generated from enum value: SOXR_DOUBLE_PRECISION = 4;
   */
  SOXR_DOUBLE_PRECISION = 4,

  /**
   * 1 << 5
   *
   * @generated from enum value: SOXR_VR = 5;
   */
  SOXR_VR = 5,
}

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

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

/**
 * @generated from enum livekit.proto.AudioSourceType
 */
export declare enum AudioSourceType {
  /**
   * Push-based audio source - manually capture frames via CaptureAudioFrameRequest
   *
   * @generated from enum value: AUDIO_SOURCE_NATIVE = 0;
   */
  AUDIO_SOURCE_NATIVE = 0,

  /**
   * Platform ADM-based audio source - captures from microphone automatically
   * Requires PlatformAudio to be created first to enable ADM recording
   *
   * @generated from enum value: AUDIO_SOURCE_PLATFORM = 1;
   */
  AUDIO_SOURCE_PLATFORM = 1,
}

/**
 * Create a new AudioStream
 * AudioStream is used to receive audio frames from a track
 *
 * @generated from message livekit.proto.NewAudioStreamRequest
 */
export declare class NewAudioStreamRequest extends Message<NewAudioStreamRequest> {
  /**
   * @generated from field: required uint64 track_handle = 1;
   */
  trackHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.AudioStreamType type = 2;
   */
  type?: AudioStreamType;

  /**
   * @generated from field: optional uint32 sample_rate = 3;
   */
  sampleRate?: number;

  /**
   * @generated from field: optional uint32 num_channels = 4;
   */
  numChannels?: number;

  /**
   * Unique identifier passed in LoadAudioFilterPluginRequest
   *
   * @generated from field: optional string audio_filter_module_id = 5;
   */
  audioFilterModuleId?: string;

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

  /**
   * @generated from field: optional uint32 frame_size_ms = 7;
   */
  frameSizeMs?: number;

  /**
   * Maximum number of queued WebRTC sink frames. Each frame is typically 10 ms
   * of decoded PCM audio on the receive path. Omit this field to use the
   * default bounded queue size of 10 frames. Set it to 0 to request unbounded
   * buffering.
   *
   * If your application consumes both audio and video, keep the queue sizing
   * strategy coordinated across both streams. Using a much larger queue, or
   * unbounded buffering, for only one of them can increase end-to-end latency
   * for that stream and cause audio/video drift.
   *
   * @generated from field: optional uint32 queue_size_frames = 8;
   */
  queueSizeFrames?: number;

  constructor(data?: PartialMessage<NewAudioStreamRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<NewAudioStreamResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: required livekit.proto.AudioStreamType type = 2;
   */
  type?: AudioStreamType;

  /**
   * @generated from field: optional livekit.proto.TrackSource track_source = 3;
   */
  trackSource?: TrackSource;

  /**
   * @generated from field: optional uint32 sample_rate = 5;
   */
  sampleRate?: number;

  /**
   * @generated from field: optional uint32 num_channels = 6;
   */
  numChannels?: number;

  /**
   * @generated from field: optional string audio_filter_module_id = 7;
   */
  audioFilterModuleId?: string;

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

  /**
   * @generated from field: optional uint32 frame_size_ms = 9;
   */
  frameSizeMs?: number;

  /**
   * Maximum number of queued WebRTC sink frames. Each frame is typically 10 ms
   * of decoded PCM audio on the receive path. Omit this field to use the
   * default bounded queue size of 10 frames. Set it to 0 to request unbounded
   * buffering.
   *
   * If your application consumes both audio and video, keep the queue sizing
   * strategy coordinated across both streams. Using a much larger queue, or
   * unbounded buffering, for only one of them can increase end-to-end latency
   * for that stream and cause audio/video drift.
   *
   * @generated from field: optional uint32 queue_size_frames = 10;
   */
  queueSizeFrames?: number;

  constructor(data?: PartialMessage<AudioStreamFromParticipantRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<AudioStreamFromParticipantResponse>);

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

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

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

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

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

/**
 * Create a new AudioSource
 *
 * @generated from message livekit.proto.NewAudioSourceRequest
 */
export declare class NewAudioSourceRequest extends Message<NewAudioSourceRequest> {
  /**
   * @generated from field: required livekit.proto.AudioSourceType type = 1;
   */
  type?: AudioSourceType;

  /**
   * @generated from field: optional livekit.proto.AudioSourceOptions options = 2;
   */
  options?: AudioSourceOptions;

  /**
   * Sample rate in Hz. Optional - defaults to 48000 if not specified.
   * For AudioSourcePlatform: ignored, ADM uses hardware native sample rate.
   * For AudioSourceNative with queue_size_ms=0 (fast path): ignored, frame values used directly.
   *
   * @generated from field: optional uint32 sample_rate = 3;
   */
  sampleRate?: number;

  /**
   * Number of audio channels. Optional - defaults to 1 (mono) if not specified.
   * For AudioSourcePlatform: ignored, ADM uses hardware native channels.
   * For AudioSourceNative with queue_size_ms=0 (fast path): ignored, frame values used directly.
   *
   * @generated from field: optional uint32 num_channels = 4;
   */
  numChannels?: number;

  /**
   * @generated from field: optional uint32 queue_size_ms = 5;
   */
  queueSizeMs?: number;

  /**
   * For AudioSourcePlatform: the PlatformAudio handle to configure audio processing on.
   * If provided with options, audio processing will be configured on the PlatformAudio.
   *
   * @generated from field: optional uint64 platform_audio_handle = 6;
   */
  platformAudioHandle?: bigint;

  constructor(data?: PartialMessage<NewAudioSourceRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<NewAudioSourceResponse>);

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

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

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

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

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

/**
 * Push a frame to an AudioSource
 * The data provided must be available as long as the client receive the callback.
 *
 * @generated from message livekit.proto.CaptureAudioFrameRequest
 */
export declare class CaptureAudioFrameRequest extends Message<CaptureAudioFrameRequest> {
  /**
   * @generated from field: required uint64 source_handle = 1;
   */
  sourceHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.AudioFrameBufferInfo buffer = 2;
   */
  buffer?: AudioFrameBufferInfo;

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

  constructor(data?: PartialMessage<CaptureAudioFrameRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<CaptureAudioFrameResponse>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<CaptureAudioFrameCallback>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ClearAudioBufferRequest>);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<NewAudioResamplerResponse>);

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

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

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

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

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

/**
 * Remix and resample an audio frame
 *
 * @generated from message livekit.proto.RemixAndResampleRequest
 */
export declare class RemixAndResampleRequest extends Message<RemixAndResampleRequest> {
  /**
   * @generated from field: required uint64 resampler_handle = 1;
   */
  resamplerHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.AudioFrameBufferInfo buffer = 2;
   */
  buffer?: AudioFrameBufferInfo;

  /**
   * @generated from field: required uint32 num_channels = 3;
   */
  numChannels?: number;

  /**
   * @generated from field: required uint32 sample_rate = 4;
   */
  sampleRate?: number;

  constructor(data?: PartialMessage<RemixAndResampleRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<RemixAndResampleResponse>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.NewApmRequest
 */
export declare class NewApmRequest extends Message<NewApmRequest> {
  /**
   * @generated from field: required bool echo_canceller_enabled = 1;
   */
  echoCancellerEnabled?: boolean;

  /**
   * @generated from field: required bool gain_controller_enabled = 2;
   */
  gainControllerEnabled?: boolean;

  /**
   * @generated from field: required bool high_pass_filter_enabled = 3;
   */
  highPassFilterEnabled?: boolean;

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

  constructor(data?: PartialMessage<NewApmRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<NewApmResponse>);

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

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

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

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

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

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

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

  /**
   * in bytes
   *
   * @generated from field: required uint32 size = 3;
   */
  size?: number;

  /**
   * @generated from field: required uint32 sample_rate = 4;
   */
  sampleRate?: number;

  /**
   * @generated from field: required uint32 num_channels = 5;
   */
  numChannels?: number;

  constructor(data?: PartialMessage<ApmProcessStreamRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.ApmProcessStreamResponse
 */
export declare class ApmProcessStreamResponse extends Message<ApmProcessStreamResponse> {
  /**
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<ApmProcessStreamResponse>);

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

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

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

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

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

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

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

  /**
   * in bytes
   *
   * @generated from field: required uint32 size = 3;
   */
  size?: number;

  /**
   * @generated from field: required uint32 sample_rate = 4;
   */
  sampleRate?: number;

  /**
   * @generated from field: required uint32 num_channels = 5;
   */
  numChannels?: number;

  constructor(data?: PartialMessage<ApmProcessReverseStreamRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.ApmProcessReverseStreamResponse
 */
export declare class ApmProcessReverseStreamResponse extends Message<ApmProcessReverseStreamResponse> {
  /**
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<ApmProcessReverseStreamResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: required int32 delay_ms = 2;
   */
  delayMs?: number;

  constructor(data?: PartialMessage<ApmSetStreamDelayRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.ApmSetStreamDelayResponse
 */
export declare class ApmSetStreamDelayResponse extends Message<ApmSetStreamDelayResponse> {
  /**
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<ApmSetStreamDelayResponse>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.NewSoxResamplerRequest
 */
export declare class NewSoxResamplerRequest extends Message<NewSoxResamplerRequest> {
  /**
   * @generated from field: required double input_rate = 1;
   */
  inputRate?: number;

  /**
   * @generated from field: required double output_rate = 2;
   */
  outputRate?: number;

  /**
   * @generated from field: required uint32 num_channels = 3;
   */
  numChannels?: number;

  /**
   * @generated from field: required livekit.proto.SoxResamplerDataType input_data_type = 4;
   */
  inputDataType?: SoxResamplerDataType;

  /**
   * @generated from field: required livekit.proto.SoxResamplerDataType output_data_type = 5;
   */
  outputDataType?: SoxResamplerDataType;

  /**
   * @generated from field: required livekit.proto.SoxQualityRecipe quality_recipe = 6;
   */
  qualityRecipe?: SoxQualityRecipe;

  /**
   * @generated from field: optional uint32 flags = 7;
   */
  flags?: number;

  constructor(data?: PartialMessage<NewSoxResamplerRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.NewSoxResamplerResponse
 */
export declare class NewSoxResamplerResponse extends Message<NewSoxResamplerResponse> {
  /**
   * @generated from oneof livekit.proto.NewSoxResamplerResponse.message
   */
  message: {
    /**
     * @generated from field: livekit.proto.OwnedSoxResampler resampler = 1;
     */
    value: OwnedSoxResampler;
    case: "resampler";
  } | {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<NewSoxResamplerResponse>);

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

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

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

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

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

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

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

  /**
   * in bytes
   *
   * @generated from field: required uint32 size = 3;
   */
  size?: number;

  constructor(data?: PartialMessage<PushSoxResamplerRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.PushSoxResamplerResponse
 */
export declare class PushSoxResamplerResponse extends Message<PushSoxResamplerResponse> {
  /**
   * *const i16 (could be null)
   *
   * @generated from field: required uint64 output_ptr = 1;
   */
  outputPtr?: bigint;

  /**
   * in bytes
   *
   * @generated from field: required uint32 size = 2;
   */
  size?: number;

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

  constructor(data?: PartialMessage<PushSoxResamplerResponse>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<FlushSoxResamplerRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.FlushSoxResamplerResponse
 */
export declare class FlushSoxResamplerResponse extends Message<FlushSoxResamplerResponse> {
  /**
   * *const i16 (could be null)
   *
   * @generated from field: required uint64 output_ptr = 1;
   */
  outputPtr?: bigint;

  /**
   * in bytes
   *
   * @generated from field: required uint32 size = 2;
   */
  size?: number;

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

  constructor(data?: PartialMessage<FlushSoxResamplerResponse>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.AudioFrameBufferInfo
 */
export declare class AudioFrameBufferInfo extends Message<AudioFrameBufferInfo> {
  /**
   * *const i16
   *
   * @generated from field: required uint64 data_ptr = 1;
   */
  dataPtr?: bigint;

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

  /**
   * @generated from field: required uint32 sample_rate = 3;
   */
  sampleRate?: number;

  /**
   * @generated from field: required uint32 samples_per_channel = 4;
   */
  samplesPerChannel?: number;

  constructor(data?: PartialMessage<AudioFrameBufferInfo>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedAudioFrameBuffer>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<AudioStreamInfo>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedAudioStream>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.AudioStreamEvent.message
   */
  message: {
    /**
     * @generated from field: livekit.proto.AudioFrameReceived frame_received = 2;
     */
    value: AudioFrameReceived;
    case: "frameReceived";
  } | {
    /**
     * @generated from field: livekit.proto.AudioStreamEOS eos = 3;
     */
    value: AudioStreamEOS;
    case: "eos";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<AudioStreamEvent>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<AudioFrameReceived>);

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message livekit.proto.AudioSourceOptions
 */
export declare class AudioSourceOptions extends Message<AudioSourceOptions> {
  /**
   * @generated from field: required bool echo_cancellation = 1;
   */
  echoCancellation?: boolean;

  /**
   * @generated from field: required bool noise_suppression = 2;
   */
  noiseSuppression?: boolean;

  /**
   * @generated from field: required bool auto_gain_control = 3;
   */
  autoGainControl?: boolean;

  /**
   * Prefer hardware audio processing (e.g., iOS VPIO). Lower latency.
   * Only applies to AudioSourcePlatform. Default: true.
   *
   * @generated from field: optional bool prefer_hardware = 4;
   */
  preferHardware?: boolean;

  constructor(data?: PartialMessage<AudioSourceOptions>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.AudioSourceInfo
 */
export declare class AudioSourceInfo extends Message<AudioSourceInfo> {
  /**
   * @generated from field: required livekit.proto.AudioSourceType type = 2;
   */
  type?: AudioSourceType;

  constructor(data?: PartialMessage<AudioSourceInfo>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedAudioSource>);

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

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

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

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

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

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

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedAudioResampler>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedApm>);

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

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

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

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

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

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

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedSoxResampler>);

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

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

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

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

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

/**
 * Audio Filter Plugin
 *
 * @generated from message livekit.proto.LoadAudioFilterPluginRequest
 */
export declare class LoadAudioFilterPluginRequest extends Message<LoadAudioFilterPluginRequest> {
  /**
   * path for ffi audio filter plugin
   *
   * @generated from field: required string plugin_path = 1;
   */
  pluginPath?: string;

  /**
   * Optional: paths for dependency dylibs
   *
   * @generated from field: repeated string dependencies = 2;
   */
  dependencies: string[];

  /**
   * Unique identifier of the plugin
   *
   * @generated from field: required string module_id = 3;
   */
  moduleId?: string;

  constructor(data?: PartialMessage<LoadAudioFilterPluginRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.LoadAudioFilterPluginResponse
 */
export declare class LoadAudioFilterPluginResponse extends Message<LoadAudioFilterPluginResponse> {
  /**
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<LoadAudioFilterPluginResponse>);

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

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

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

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

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

/**
 * Information about an audio device.
 *
 * @generated from message livekit.proto.AudioDeviceInfo
 */
export declare class AudioDeviceInfo extends Message<AudioDeviceInfo> {
  /**
   * Device index (0-based). Note: indices can change when devices are added/removed.
   *
   * @generated from field: required uint32 index = 1;
   */
  index?: number;

  /**
   * Device name as reported by the operating system.
   *
   * @generated from field: required string name = 2;
   */
  name?: string;

  /**
   * Platform-specific unique device identifier (GUID).
   * This is stable across device additions/removals and should be preferred
   * over index for device selection. Format varies by platform:
   * - Windows: Device interface path
   * - macOS: AudioObjectID as string
   * - Linux: ALSA/PulseAudio device identifier
   *
   * @generated from field: optional string guid = 3;
   */
  guid?: string;

  constructor(data?: PartialMessage<AudioDeviceInfo>);

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

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

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

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

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

/**
 * Information about a PlatformAudio instance.
 *
 * @generated from message livekit.proto.PlatformAudioInfo
 */
export declare class PlatformAudioInfo extends Message<PlatformAudioInfo> {
  /**
   * Number of available recording (microphone) devices.
   *
   * @generated from field: required int32 recording_device_count = 1;
   */
  recordingDeviceCount?: number;

  /**
   * Number of available playout (speaker) devices.
   *
   * @generated from field: required int32 playout_device_count = 2;
   */
  playoutDeviceCount?: number;

  constructor(data?: PartialMessage<PlatformAudioInfo>);

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

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

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

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

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

/**
 * Owned PlatformAudio handle with info.
 *
 * @generated from message livekit.proto.OwnedPlatformAudio
 */
export declare class OwnedPlatformAudio extends Message<OwnedPlatformAudio> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

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

  constructor(data?: PartialMessage<OwnedPlatformAudio>);

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

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

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

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

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

/**
 * Create a new PlatformAudio instance.
 *
 * This enables the platform ADM for microphone capture and speaker playout.
 * If another PlatformAudio instance exists, this reuses the same underlying ADM.
 *
 * The returned handle must be kept alive while platform audio is needed.
 * When all handles are released, the ADM is automatically disabled.
 *
 * @generated from message livekit.proto.NewPlatformAudioRequest
 */
export declare class NewPlatformAudioRequest extends Message<NewPlatformAudioRequest> {
  constructor(data?: PartialMessage<NewPlatformAudioRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.NewPlatformAudioResponse
 */
export declare class NewPlatformAudioResponse extends Message<NewPlatformAudioResponse> {
  /**
   * @generated from oneof livekit.proto.NewPlatformAudioResponse.message
   */
  message: {
    /**
     * The PlatformAudio handle on success.
     *
     * @generated from field: livekit.proto.OwnedPlatformAudio platform_audio = 1;
     */
    value: OwnedPlatformAudio;
    case: "platformAudio";
  } | {
    /**
     * Error message if creation failed.
     *
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<NewPlatformAudioResponse>);

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

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

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

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

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

/**
 * Get available audio devices.
 *
 * Returns lists of available recording (microphone) and playout (speaker) devices.
 *
 * # Platform Notes
 *
 * - Desktop (Windows/macOS/Linux): Returns all available devices with names and GUIDs.
 * - Mobile (iOS/Android): Returns only one "default" device with empty name and GUID.
 *   Device enumeration is not meaningful on mobile - use for device count only.
 *
 * @generated from message livekit.proto.GetAudioDevicesRequest
 */
export declare class GetAudioDevicesRequest extends Message<GetAudioDevicesRequest> {
  /**
   * The PlatformAudio handle.
   *
   * @generated from field: required uint64 platform_audio_handle = 1;
   */
  platformAudioHandle?: bigint;

  constructor(data?: PartialMessage<GetAudioDevicesRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.GetAudioDevicesResponse
 */
export declare class GetAudioDevicesResponse extends Message<GetAudioDevicesResponse> {
  /**
   * Available playout devices (speakers/headphones).
   *
   * @generated from field: repeated livekit.proto.AudioDeviceInfo playout_devices = 1;
   */
  playoutDevices: AudioDeviceInfo[];

  /**
   * Available recording devices (microphones).
   *
   * @generated from field: repeated livekit.proto.AudioDeviceInfo recording_devices = 2;
   */
  recordingDevices: AudioDeviceInfo[];

  /**
   * Error message if enumeration failed, empty/absent on success.
   *
   * @generated from field: optional string error = 3;
   */
  error?: string;

  constructor(data?: PartialMessage<GetAudioDevicesResponse>);

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

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

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

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

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

/**
 * Set the recording device (microphone).
 *
 * Call this before creating audio tracks to select which microphone to use.
 * Use the GUID from AudioDeviceInfo for stable device selection across hot-plug events.
 *
 * # Platform Notes
 *
 * - Desktop: Works as expected - selects from enumerated devices.
 * - Mobile (iOS/Android): No-op. Mobile platforms handle microphone selection at the
 *   system level. This will succeed but has no effect. Skip calling on mobile.
 *
 * @generated from message livekit.proto.SetRecordingDeviceRequest
 */
export declare class SetRecordingDeviceRequest extends Message<SetRecordingDeviceRequest> {
  /**
   * The PlatformAudio handle.
   *
   * @generated from field: required uint64 platform_audio_handle = 1;
   */
  platformAudioHandle?: bigint;

  /**
   * Device GUID from AudioDeviceInfo.guid - stable across device additions/removals.
   *
   * @generated from field: required string device_id = 2;
   */
  deviceId?: string;

  constructor(data?: PartialMessage<SetRecordingDeviceRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.SetRecordingDeviceResponse
 */
export declare class SetRecordingDeviceResponse extends Message<SetRecordingDeviceResponse> {
  /**
   * Error message if the operation failed.
   * Empty/absent on success (including no-op success on mobile).
   *
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<SetRecordingDeviceResponse>);

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

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

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

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

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

/**
 * Set the playout device (speaker/headphones).
 *
 * Call this before connecting to select which speaker to use for audio output.
 * Use the GUID from AudioDeviceInfo for stable device selection across hot-plug events.
 *
 * # Platform Notes
 *
 * - Desktop: Works as expected - selects from enumerated devices.
 * - Mobile (iOS/Android): No-op. Mobile platforms handle audio routing at the system level.
 *   This will succeed but has no effect. For audio routing on mobile:
 *   - iOS: Use AVAudioSession to control speaker/earpiece/Bluetooth routing
 *   - Android: Use AudioManager.setSpeakerphoneOn() to switch outputs
 *
 * @generated from message livekit.proto.SetPlayoutDeviceRequest
 */
export declare class SetPlayoutDeviceRequest extends Message<SetPlayoutDeviceRequest> {
  /**
   * The PlatformAudio handle.
   *
   * @generated from field: required uint64 platform_audio_handle = 1;
   */
  platformAudioHandle?: bigint;

  /**
   * Device GUID from AudioDeviceInfo.guid - stable across device additions/removals.
   *
   * @generated from field: required string device_id = 2;
   */
  deviceId?: string;

  constructor(data?: PartialMessage<SetPlayoutDeviceRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.SetPlayoutDeviceResponse
 */
export declare class SetPlayoutDeviceResponse extends Message<SetPlayoutDeviceResponse> {
  /**
   * Error message if the operation failed.
   * Empty/absent on success (including no-op success on mobile).
   *
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<SetPlayoutDeviceResponse>);

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

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

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

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

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

/**
 * Start recording from the microphone.
 *
 * Recording is started automatically when PlatformAudio is created.
 * Use this to resume recording after calling StopRecording.
 * This also turns on the system's recording privacy indicator.
 *
 * @generated from message livekit.proto.StartRecordingRequest
 */
export declare class StartRecordingRequest extends Message<StartRecordingRequest> {
  /**
   * The PlatformAudio handle.
   *
   * @generated from field: required uint64 platform_audio_handle = 1;
   */
  platformAudioHandle?: bigint;

  constructor(data?: PartialMessage<StartRecordingRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.StartRecordingResponse
 */
export declare class StartRecordingResponse extends Message<StartRecordingResponse> {
  /**
   * Error message if the operation failed.
   * Empty/absent on success.
   *
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<StartRecordingResponse>);

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

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

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

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

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

/**
 * Stop recording from the microphone.
 *
 * Use this to temporarily stop recording without disposing PlatformAudio.
 * This will turn off the system's recording privacy indicator (e.g., on macOS/iOS).
 * Call StartRecording to resume recording.
 *
 * @generated from message livekit.proto.StopRecordingRequest
 */
export declare class StopRecordingRequest extends Message<StopRecordingRequest> {
  /**
   * The PlatformAudio handle.
   *
   * @generated from field: required uint64 platform_audio_handle = 1;
   */
  platformAudioHandle?: bigint;

  constructor(data?: PartialMessage<StopRecordingRequest>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.StopRecordingResponse
 */
export declare class StopRecordingResponse extends Message<StopRecordingResponse> {
  /**
   * Error message if the operation failed.
   * Empty/absent on success.
   *
   * @generated from field: optional string error = 1;
   */
  error?: string;

  constructor(data?: PartialMessage<StopRecordingResponse>);

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

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

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

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

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