// 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 data_stream.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 { FfiOwnedHandle } from "./handle_pb.js";
import type { EncryptionType } from "./e2ee_pb.js";

/**
 * A reader for an incoming stream.
 *
 * @generated from message livekit.proto.OwnedTextStreamReader
 */
export declare class OwnedTextStreamReader extends Message<OwnedTextStreamReader> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

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

  constructor(data?: PartialMessage<OwnedTextStreamReader>);

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

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

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

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

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

/**
 * Reads an incoming text stream incrementally.
 *
 * @generated from message livekit.proto.TextStreamReaderReadIncrementalRequest
 */
export declare class TextStreamReaderReadIncrementalRequest extends Message<TextStreamReaderReadIncrementalRequest> {
  /**
   * @generated from field: required uint64 reader_handle = 1;
   */
  readerHandle?: bigint;

  constructor(data?: PartialMessage<TextStreamReaderReadIncrementalRequest>);

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

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

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

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

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

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

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

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

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

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

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

/**
 * Reads an incoming text stream in its entirety.
 *
 * @generated from message livekit.proto.TextStreamReaderReadAllRequest
 */
export declare class TextStreamReaderReadAllRequest extends Message<TextStreamReaderReadAllRequest> {
  /**
   * @generated from field: required uint64 reader_handle = 1;
   */
  readerHandle?: bigint;

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

  constructor(data?: PartialMessage<TextStreamReaderReadAllRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamReaderReadAllResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.TextStreamReaderReadAllCallback.result
   */
  result: {
    /**
     * @generated from field: string content = 2;
     */
    value: string;
    case: "content";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<TextStreamReaderReadAllCallback>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.TextStreamReaderEvent.detail
   */
  detail: {
    /**
     * @generated from field: livekit.proto.TextStreamReaderChunkReceived chunk_received = 2;
     */
    value: TextStreamReaderChunkReceived;
    case: "chunkReceived";
  } | {
    /**
     * @generated from field: livekit.proto.TextStreamReaderEOS eos = 3;
     */
    value: TextStreamReaderEOS;
    case: "eos";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<TextStreamReaderEvent>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamReaderChunkReceived>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamReaderEOS>);

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

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

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

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

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

/**
 * A reader for an incoming stream.
 *
 * @generated from message livekit.proto.OwnedByteStreamReader
 */
export declare class OwnedByteStreamReader extends Message<OwnedByteStreamReader> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

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

  constructor(data?: PartialMessage<OwnedByteStreamReader>);

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

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

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

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

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

/**
 * Reads an incoming byte stream incrementally.
 *
 * @generated from message livekit.proto.ByteStreamReaderReadIncrementalRequest
 */
export declare class ByteStreamReaderReadIncrementalRequest extends Message<ByteStreamReaderReadIncrementalRequest> {
  /**
   * @generated from field: required uint64 reader_handle = 1;
   */
  readerHandle?: bigint;

  constructor(data?: PartialMessage<ByteStreamReaderReadIncrementalRequest>);

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

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

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

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

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

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

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

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

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

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

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

/**
 * Reads an incoming byte stream in its entirety.
 *
 * @generated from message livekit.proto.ByteStreamReaderReadAllRequest
 */
export declare class ByteStreamReaderReadAllRequest extends Message<ByteStreamReaderReadAllRequest> {
  /**
   * @generated from field: required uint64 reader_handle = 1;
   */
  readerHandle?: bigint;

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

  constructor(data?: PartialMessage<ByteStreamReaderReadAllRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamReaderReadAllResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.ByteStreamReaderReadAllCallback.result
   */
  result: {
    /**
     * @generated from field: bytes content = 2;
     */
    value: Uint8Array;
    case: "content";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ByteStreamReaderReadAllCallback>);

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

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

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

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

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

/**
 * Writes data from an incoming stream to a file as it arrives.
 *
 * @generated from message livekit.proto.ByteStreamReaderWriteToFileRequest
 */
export declare class ByteStreamReaderWriteToFileRequest extends Message<ByteStreamReaderWriteToFileRequest> {
  /**
   * @generated from field: required uint64 reader_handle = 1;
   */
  readerHandle?: bigint;

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

  /**
   * Directory to write the file in (must be writable by the current process).
   * If not provided, the file will be written to the system's temp directory.
   *
   * @generated from field: optional string directory = 3;
   */
  directory?: string;

  /**
   * Name to use for the written file.
   * If not provided, the file's name and extension will be inferred from
   * the stream's info.
   *
   * @generated from field: optional string name_override = 4;
   */
  nameOverride?: string;

  constructor(data?: PartialMessage<ByteStreamReaderWriteToFileRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamReaderWriteToFileResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.ByteStreamReaderWriteToFileCallback.result
   */
  result: {
    /**
     * Path the file was written to.
     *
     * @generated from field: string file_path = 2;
     */
    value: string;
    case: "filePath";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ByteStreamReaderWriteToFileCallback>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.ByteStreamReaderEvent.detail
   */
  detail: {
    /**
     * @generated from field: livekit.proto.ByteStreamReaderChunkReceived chunk_received = 2;
     */
    value: ByteStreamReaderChunkReceived;
    case: "chunkReceived";
  } | {
    /**
     * @generated from field: livekit.proto.ByteStreamReaderEOS eos = 3;
     */
    value: ByteStreamReaderEOS;
    case: "eos";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ByteStreamReaderEvent>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.ByteStreamReaderChunkReceived
 */
export declare class ByteStreamReaderChunkReceived extends Message<ByteStreamReaderChunkReceived> {
  /**
   * @generated from field: required bytes content = 1;
   */
  content?: Uint8Array;

  constructor(data?: PartialMessage<ByteStreamReaderChunkReceived>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamReaderEOS>);

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

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

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

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

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

/**
 * Sends the contents of a file over a data stream.
 *
 * @generated from message livekit.proto.StreamSendFileRequest
 */
export declare class StreamSendFileRequest extends Message<StreamSendFileRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.StreamByteOptions options = 2;
   */
  options?: StreamByteOptions;

  /**
   * Path of the file to send (must be readable by the current process).
   *
   * @generated from field: required string file_path = 3;
   */
  filePath?: string;

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

  constructor(data?: PartialMessage<StreamSendFileRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<StreamSendFileResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.StreamSendFileCallback.result
   */
  result: {
    /**
     * @generated from field: livekit.proto.ByteStreamInfo info = 2;
     */
    value: ByteStreamInfo;
    case: "info";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<StreamSendFileCallback>);

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

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

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

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

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

/**
 * Sends bytes over a data stream.
 *
 * @generated from message livekit.proto.StreamSendBytesRequest
 */
export declare class StreamSendBytesRequest extends Message<StreamSendBytesRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.StreamByteOptions options = 2;
   */
  options?: StreamByteOptions;

  /**
   * Bytes to send.
   *
   * @generated from field: required bytes bytes = 3;
   */
  bytes?: Uint8Array;

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

  constructor(data?: PartialMessage<StreamSendBytesRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<StreamSendBytesResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.StreamSendBytesCallback.result
   */
  result: {
    /**
     * @generated from field: livekit.proto.ByteStreamInfo info = 2;
     */
    value: ByteStreamInfo;
    case: "info";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<StreamSendBytesCallback>);

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

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

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

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

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

/**
 * Sends text over a data stream.
 *
 * @generated from message livekit.proto.StreamSendTextRequest
 */
export declare class StreamSendTextRequest extends Message<StreamSendTextRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.StreamTextOptions options = 2;
   */
  options?: StreamTextOptions;

  /**
   * Text to send.
   *
   * @generated from field: required string text = 3;
   */
  text?: string;

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

  constructor(data?: PartialMessage<StreamSendTextRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<StreamSendTextResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.StreamSendTextCallback.result
   */
  result: {
    /**
     * @generated from field: livekit.proto.TextStreamInfo info = 2;
     */
    value: TextStreamInfo;
    case: "info";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<StreamSendTextCallback>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedByteStreamWriter>);

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

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

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

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

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

/**
 * Opens an outgoing stream.
 * Call must be balanced with a StreamCloseRequest.
 *
 * @generated from message livekit.proto.ByteStreamOpenRequest
 */
export declare class ByteStreamOpenRequest extends Message<ByteStreamOpenRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * Options to use for opening the stream.
   *
   * @generated from field: required livekit.proto.StreamByteOptions options = 2;
   */
  options?: StreamByteOptions;

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

  constructor(data?: PartialMessage<ByteStreamOpenRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamOpenResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.ByteStreamOpenCallback.result
   */
  result: {
    /**
     * @generated from field: livekit.proto.OwnedByteStreamWriter writer = 2;
     */
    value: OwnedByteStreamWriter;
    case: "writer";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ByteStreamOpenCallback>);

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

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

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

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

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

/**
 * Writes data to a stream writer.
 *
 * @generated from message livekit.proto.ByteStreamWriterWriteRequest
 */
export declare class ByteStreamWriterWriteRequest extends Message<ByteStreamWriterWriteRequest> {
  /**
   * @generated from field: required uint64 writer_handle = 1;
   */
  writerHandle?: bigint;

  /**
   * @generated from field: required bytes bytes = 2;
   */
  bytes?: Uint8Array;

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

  constructor(data?: PartialMessage<ByteStreamWriterWriteRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamWriterWriteResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: optional livekit.proto.StreamError error = 2;
   */
  error?: StreamError;

  constructor(data?: PartialMessage<ByteStreamWriterWriteCallback>);

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

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

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

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

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

/**
 * Closes a stream writer.
 *
 * @generated from message livekit.proto.ByteStreamWriterCloseRequest
 */
export declare class ByteStreamWriterCloseRequest extends Message<ByteStreamWriterCloseRequest> {
  /**
   * @generated from field: required uint64 writer_handle = 1;
   */
  writerHandle?: bigint;

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

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

  constructor(data?: PartialMessage<ByteStreamWriterCloseRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<ByteStreamWriterCloseResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: optional livekit.proto.StreamError error = 2;
   */
  error?: StreamError;

  constructor(data?: PartialMessage<ByteStreamWriterCloseCallback>);

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<OwnedTextStreamWriter>);

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

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

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

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

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

/**
 * Opens an outgoing text stream.
 * Call must be balanced with a TextStreamCloseRequest.
 *
 * @generated from message livekit.proto.TextStreamOpenRequest
 */
export declare class TextStreamOpenRequest extends Message<TextStreamOpenRequest> {
  /**
   * @generated from field: required uint64 local_participant_handle = 1;
   */
  localParticipantHandle?: bigint;

  /**
   * Options to use for opening the stream.
   *
   * @generated from field: required livekit.proto.StreamTextOptions options = 2;
   */
  options?: StreamTextOptions;

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

  constructor(data?: PartialMessage<TextStreamOpenRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamOpenResponse>);

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

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

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

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

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

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

  /**
   * @generated from oneof livekit.proto.TextStreamOpenCallback.result
   */
  result: {
    /**
     * @generated from field: livekit.proto.OwnedTextStreamWriter writer = 2;
     */
    value: OwnedTextStreamWriter;
    case: "writer";
  } | {
    /**
     * @generated from field: livekit.proto.StreamError error = 3;
     */
    value: StreamError;
    case: "error";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<TextStreamOpenCallback>);

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

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

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

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

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

/**
 * Writes text to a text stream writer.
 *
 * @generated from message livekit.proto.TextStreamWriterWriteRequest
 */
export declare class TextStreamWriterWriteRequest extends Message<TextStreamWriterWriteRequest> {
  /**
   * @generated from field: required uint64 writer_handle = 1;
   */
  writerHandle?: bigint;

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

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

  constructor(data?: PartialMessage<TextStreamWriterWriteRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamWriterWriteResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: optional livekit.proto.StreamError error = 2;
   */
  error?: StreamError;

  constructor(data?: PartialMessage<TextStreamWriterWriteCallback>);

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

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

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

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

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

/**
 * Closes a text stream writer.
 *
 * @generated from message livekit.proto.TextStreamWriterCloseRequest
 */
export declare class TextStreamWriterCloseRequest extends Message<TextStreamWriterCloseRequest> {
  /**
   * @generated from field: required uint64 writer_handle = 1;
   */
  writerHandle?: bigint;

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

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

  constructor(data?: PartialMessage<TextStreamWriterCloseRequest>);

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

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

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

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

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

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

  constructor(data?: PartialMessage<TextStreamWriterCloseResponse>);

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

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

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

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

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

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

  /**
   * @generated from field: optional livekit.proto.StreamError error = 2;
   */
  error?: StreamError;

  constructor(data?: PartialMessage<TextStreamWriterCloseCallback>);

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

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

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

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

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

/**
 * @generated from message livekit.proto.TextStreamInfo
 */
export declare class TextStreamInfo extends Message<TextStreamInfo> {
  /**
   * 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 };

  /**
   * @generated from field: required livekit.proto.TextStreamInfo.OperationType operation_type = 7;
   */
  operationType?: TextStreamInfo_OperationType;

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

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

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

  /**
   * true if the text has been generated by an agent from a participant's audio transcription
   *
   * @generated from field: optional bool generated = 11;
   */
  generated?: boolean;

  /**
   * @generated from field: required livekit.proto.EncryptionType encryption_type = 12;
   */
  encryptionType?: EncryptionType;

  constructor(data?: PartialMessage<TextStreamInfo>);

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

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

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

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

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

/**
 * @generated from enum livekit.proto.TextStreamInfo.OperationType
 */
export declare enum TextStreamInfo_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,
}

/**
 * @generated from message livekit.proto.ByteStreamInfo
 */
export declare class ByteStreamInfo extends Message<ByteStreamInfo> {
  /**
   * 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 };

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

  /**
   * @generated from field: required livekit.proto.EncryptionType encryption_type = 8;
   */
  encryptionType?: EncryptionType;

  constructor(data?: PartialMessage<ByteStreamInfo>);

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

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

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

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

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

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

  /**
   * @generated from field: map<string, string> attributes = 2;
   */
  attributes: { [key: string]: string };

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

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

  /**
   * @generated from field: optional livekit.proto.TextStreamInfo.OperationType operation_type = 5;
   */
  operationType?: TextStreamInfo_OperationType;

  /**
   * @generated from field: optional int32 version = 6;
   */
  version?: number;

  /**
   * @generated from field: optional string reply_to_stream_id = 7;
   */
  replyToStreamId?: string;

  /**
   * @generated from field: repeated string attached_stream_ids = 8;
   */
  attachedStreamIds: string[];

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

  constructor(data?: PartialMessage<StreamTextOptions>);

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

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

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

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

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

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

  /**
   * @generated from field: map<string, string> attributes = 2;
   */
  attributes: { [key: string]: string };

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

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

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

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

  /**
   * @generated from field: optional uint64 total_length = 7;
   */
  totalLength?: bigint;

  constructor(data?: PartialMessage<StreamByteOptions>);

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

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

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

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

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

/**
 * Error pertaining to a stream.
 *
 * @generated from message livekit.proto.StreamError
 */
export declare class StreamError extends Message<StreamError> {
  /**
   * TODO(ladvoc): make this an enum.
   *
   * @generated from field: required string description = 1;
   */
  description?: string;

  constructor(data?: PartialMessage<StreamError>);

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

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

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

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

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