@livekit/rtc-node 0.13.13 → 0.13.16

package/dist/proto/data_stream_pb.d.cts

@@ -0,0 +1,1358 @@
+import { Message, PartialMessage, proto2, FieldList, BinaryReadOptions, JsonValue, JsonReadOptions, PlainMessage } from '@bufbuild/protobuf';
+import { FfiOwnedHandle } from './handle_pb.cjs';
+
+/**
+ * A reader for an incoming stream.
+ *
+ * @generated from message livekit.proto.OwnedTextStreamReader
+ */
+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
+ */
+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
+ */
+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
+ */
+declare class TextStreamReaderReadAllRequest extends Message<TextStreamReaderReadAllRequest> {
+    /**
+     * @generated from field: required uint64 reader_handle = 1;
+     */
+    readerHandle?: 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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+declare class ByteStreamReaderReadAllRequest extends Message<ByteStreamReaderReadAllRequest> {
+    /**
+     * @generated from field: required uint64 reader_handle = 1;
+     */
+    readerHandle?: 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
+ */
+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
+ */
+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
+ */
+declare class ByteStreamReaderWriteToFileRequest extends Message<ByteStreamReaderWriteToFileRequest> {
+    /**
+     * @generated from field: required uint64 reader_handle = 1;
+     */
+    readerHandle?: 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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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 text over a data stream.
+ *
+ * @generated from message livekit.proto.StreamSendTextRequest
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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;
+    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
+ */
+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
+ */
+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
+ */
+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;
+}
+
+export { ByteStreamInfo, ByteStreamOpenCallback, ByteStreamOpenRequest, ByteStreamOpenResponse, ByteStreamReaderChunkReceived, ByteStreamReaderEOS, ByteStreamReaderEvent, ByteStreamReaderReadAllCallback, ByteStreamReaderReadAllRequest, ByteStreamReaderReadAllResponse, ByteStreamReaderReadIncrementalRequest, ByteStreamReaderReadIncrementalResponse, ByteStreamReaderWriteToFileCallback, ByteStreamReaderWriteToFileRequest, ByteStreamReaderWriteToFileResponse, ByteStreamWriterCloseCallback, ByteStreamWriterCloseRequest, ByteStreamWriterCloseResponse, ByteStreamWriterWriteCallback, ByteStreamWriterWriteRequest, ByteStreamWriterWriteResponse, OwnedByteStreamReader, OwnedByteStreamWriter, OwnedTextStreamReader, OwnedTextStreamWriter, StreamByteOptions, StreamError, StreamSendFileCallback, StreamSendFileRequest, StreamSendFileResponse, StreamSendTextCallback, StreamSendTextRequest, StreamSendTextResponse, StreamTextOptions, TextStreamInfo, TextStreamInfo_OperationType, TextStreamOpenCallback, TextStreamOpenRequest, TextStreamOpenResponse, TextStreamReaderChunkReceived, TextStreamReaderEOS, TextStreamReaderEvent, TextStreamReaderReadAllCallback, TextStreamReaderReadAllRequest, TextStreamReaderReadAllResponse, TextStreamReaderReadIncrementalRequest, TextStreamReaderReadIncrementalResponse, TextStreamWriterCloseCallback, TextStreamWriterCloseRequest, TextStreamWriterCloseResponse, TextStreamWriterWriteCallback, TextStreamWriterWriteRequest, TextStreamWriterWriteResponse };