From da78db9469530707c75ae747bc68eff681391848 Mon Sep 17 00:00:00 2001 From: aoife cassidy Date: Tue, 26 Nov 2024 22:09:14 +0200 Subject: [PATCH] use typescript --- package.json | 6 +- packages/javascript/.gitignore | 3 +- packages/javascript/package.json | 36 +- .../src/gen/livekit_agent_dispatch_pb.ts | 355 ++ .../javascript/src/gen/livekit_agent_pb.ts | 1011 +++++ .../src/gen/livekit_analytics_pb.ts | 1146 ++++++ .../javascript/src/gen/livekit_egress_pb.ts | 2654 +++++++++++++ .../javascript/src/gen/livekit_ingress_pb.ts | 1105 ++++++ .../javascript/src/gen/livekit_internal_pb.ts | 783 ++++ .../javascript/src/gen/livekit_metrics_pb.ts | 446 +++ .../javascript/src/gen/livekit_models_pb.ts | 3329 +++++++++++++++++ .../javascript/src/gen/livekit_room_pb.ts | 1071 ++++++ packages/javascript/src/gen/livekit_rtc_pb.ts | 2704 +++++++++++++ packages/javascript/src/gen/livekit_sip_pb.ts | 2026 ++++++++++ .../javascript/src/gen/livekit_webhook_pb.ts | 126 + packages/javascript/src/gen/version.d.ts | 1 - packages/javascript/src/gen/version.ts | 2 + packages/javascript/src/index.cjs | 28 - packages/javascript/src/index.js | 13 - .../javascript/src/{index.d.ts => index.ts} | 0 packages/javascript/tsconfig.json | 13 + packages/javascript/tsup.config.ts | 19 + pnpm-lock.yaml | 985 +++++ 23 files changed, 17797 insertions(+), 65 deletions(-) create mode 100644 packages/javascript/src/gen/livekit_agent_dispatch_pb.ts create mode 100644 packages/javascript/src/gen/livekit_agent_pb.ts create mode 100644 packages/javascript/src/gen/livekit_analytics_pb.ts create mode 100644 packages/javascript/src/gen/livekit_egress_pb.ts create mode 100644 packages/javascript/src/gen/livekit_ingress_pb.ts create mode 100644 packages/javascript/src/gen/livekit_internal_pb.ts create mode 100644 packages/javascript/src/gen/livekit_metrics_pb.ts create mode 100644 packages/javascript/src/gen/livekit_models_pb.ts create mode 100644 packages/javascript/src/gen/livekit_room_pb.ts create mode 100644 packages/javascript/src/gen/livekit_rtc_pb.ts create mode 100644 packages/javascript/src/gen/livekit_sip_pb.ts create mode 100644 packages/javascript/src/gen/livekit_webhook_pb.ts delete mode 100644 packages/javascript/src/gen/version.d.ts create mode 100644 packages/javascript/src/gen/version.ts delete mode 100644 packages/javascript/src/index.cjs delete mode 100644 packages/javascript/src/index.js rename packages/javascript/src/{index.d.ts => index.ts} (100%) create mode 100644 packages/javascript/tsconfig.json create mode 100644 packages/javascript/tsup.config.ts diff --git a/package.json b/package.json index 502b5bf0..91f085c4 100644 --- a/package.json +++ b/package.json @@ -8,6 +8,8 @@ }, "devDependencies": { "@changesets/cli": "^2.27.9", - "@livekit/changesets-changelog-github": "^0.0.4" - } + "@livekit/changesets-changelog-github": "^0.0.4", + "esbuild": "^0.24.0" + }, + "packageManager": "pnpm@9.2.0+sha1.886364ebd6dae009284bebc56ed4296bb6dd557a" } diff --git a/packages/javascript/.gitignore b/packages/javascript/.gitignore index 503c22c2..b9470778 100644 --- a/packages/javascript/.gitignore +++ b/packages/javascript/.gitignore @@ -1,3 +1,2 @@ node_modules/ -src/gen -!src/gen/version.d.ts +dist/ diff --git a/packages/javascript/package.json b/packages/javascript/package.json index 721027f8..58259e42 100644 --- a/packages/javascript/package.json +++ b/packages/javascript/package.json @@ -3,40 +3,38 @@ "version": "1.27.1", "description": "", "type": "module", - "main": "src/index.js", - "import": "src/index.cjs", - "types": "src/index.d.ts", + "main": "dist/index.js", + "import": "dist/index.cjs", + "types": "dist/index.d.ts", "files": [ - "src" + "dist" ], "exports": { ".": { - "types": "./src/index.d.ts", - "import": "./src/index.js", - "require": "./src/index.cjs" + "types": "./dist/index.d.ts", + "import": "./dist/index.js", + "require": "./dist/index.cjs" }, "./*": { - "types": "./src/gen/dts/livekit_*_pb.d.ts", - "import": "./src/gen/esm/livekit_*_pb.js", - "require": "./src/gen/cjs/livekit_*_pb.cjs" + "types": "./dist/gen/livekit_*_pb.d.ts", + "import": "./dist/gen/livekit_*_pb.js", + "require": "./dist/gen/livekit_*_pb.cjs" } }, "scripts": { - "generate:version:esm": "genversion --esm --semi src/gen/version.mjs", - "generate:version:cjs": "genversion --semi src/gen/version.cjs", - "generate:version": "pnpm generate:version:esm && pnpm generate:version:cjs", - "generate:proto:esm": "protoc --es_out src/gen --es_opt target=js -I=../../protobufs ../../protobufs/livekit_*.proto", - "generate:proto:cjs": "protoc --es_out src/gen --es_opt target=js,js_import_style=legacy_commonjs -I=../../protobufs ../../protobufs/livekit_*.proto && rename \"s/js$/cjs/\" src/gen/*.js && sed -i 's/\\.js\")/.cjs\")/' src/gen/*.cjs", - "generate:proto:dts": "protoc --es_out src/gen --es_opt target=dts -I=../../protobufs ../../protobufs/livekit_*.proto", - "generate:proto": "pnpm generate:proto:cjs && pnpm generate:proto:esm && pnpm generate:proto:dts", - "build": "pnpm generate:version && pnpm generate:proto" + "generate:version": "genversion --esm --semi src/gen/version.ts", + "generate:proto": "protoc --es_out src/gen --es_opt target=ts -I=../../protobufs ../../protobufs/livekit_*.proto", + "prebuild": "pnpm generate:version && pnpm generate:proto", + "build": "pnpm prebuild && tsup --onSuccess \"tsc --declaration --emitDeclarationOnly\"" }, "keywords": [], "author": "LiveKit", "license": "Apache-2.0", "devDependencies": { "@bufbuild/protoc-gen-es": "^1.10.0", - "genversion": "^3.2.0" + "genversion": "^3.2.0", + "tsup": "^8.3.5", + "typescript": "^5.7.2" }, "dependencies": { "@bufbuild/protobuf": "^1.10.0" diff --git a/packages/javascript/src/gen/livekit_agent_dispatch_pb.ts b/packages/javascript/src/gen/livekit_agent_dispatch_pb.ts new file mode 100644 index 00000000..cfacb0ef --- /dev/null +++ b/packages/javascript/src/gen/livekit_agent_dispatch_pb.ts @@ -0,0 +1,355 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_agent_dispatch.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { Job } from "./livekit_agent_pb.js"; + +/** + * @generated from message livekit.CreateAgentDispatchRequest + */ +export class CreateAgentDispatchRequest extends Message { + /** + * @generated from field: string agent_name = 1; + */ + agentName = ""; + + /** + * @generated from field: string room = 2; + */ + room = ""; + + /** + * @generated from field: string metadata = 3; + */ + metadata = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateAgentDispatchRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "agent_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateAgentDispatchRequest { + return new CreateAgentDispatchRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateAgentDispatchRequest { + return new CreateAgentDispatchRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateAgentDispatchRequest { + return new CreateAgentDispatchRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateAgentDispatchRequest | PlainMessage | undefined, b: CreateAgentDispatchRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateAgentDispatchRequest, a, b); + } +} + +/** + * @generated from message livekit.RoomAgentDispatch + */ +export class RoomAgentDispatch extends Message { + /** + * @generated from field: string agent_name = 1; + */ + agentName = ""; + + /** + * @generated from field: string metadata = 2; + */ + metadata = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomAgentDispatch"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "agent_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomAgentDispatch { + return new RoomAgentDispatch().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomAgentDispatch { + return new RoomAgentDispatch().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomAgentDispatch { + return new RoomAgentDispatch().fromJsonString(jsonString, options); + } + + static equals(a: RoomAgentDispatch | PlainMessage | undefined, b: RoomAgentDispatch | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomAgentDispatch, a, b); + } +} + +/** + * @generated from message livekit.DeleteAgentDispatchRequest + */ +export class DeleteAgentDispatchRequest extends Message { + /** + * @generated from field: string dispatch_id = 1; + */ + dispatchId = ""; + + /** + * @generated from field: string room = 2; + */ + room = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteAgentDispatchRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "dispatch_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteAgentDispatchRequest { + return new DeleteAgentDispatchRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteAgentDispatchRequest { + return new DeleteAgentDispatchRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteAgentDispatchRequest { + return new DeleteAgentDispatchRequest().fromJsonString(jsonString, options); + } + + static equals(a: DeleteAgentDispatchRequest | PlainMessage | undefined, b: DeleteAgentDispatchRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteAgentDispatchRequest, a, b); + } +} + +/** + * @generated from message livekit.ListAgentDispatchRequest + */ +export class ListAgentDispatchRequest extends Message { + /** + * if set, only the dispatch whose id is given will be returned + * + * @generated from field: string dispatch_id = 1; + */ + dispatchId = ""; + + /** + * name of the room to list agents for. Must be set. + * + * @generated from field: string room = 2; + */ + room = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListAgentDispatchRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "dispatch_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListAgentDispatchRequest { + return new ListAgentDispatchRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListAgentDispatchRequest { + return new ListAgentDispatchRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListAgentDispatchRequest { + return new ListAgentDispatchRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListAgentDispatchRequest | PlainMessage | undefined, b: ListAgentDispatchRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListAgentDispatchRequest, a, b); + } +} + +/** + * @generated from message livekit.ListAgentDispatchResponse + */ +export class ListAgentDispatchResponse extends Message { + /** + * @generated from field: repeated livekit.AgentDispatch agent_dispatches = 1; + */ + agentDispatches: AgentDispatch[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListAgentDispatchResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "agent_dispatches", kind: "message", T: AgentDispatch, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListAgentDispatchResponse { + return new ListAgentDispatchResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListAgentDispatchResponse { + return new ListAgentDispatchResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListAgentDispatchResponse { + return new ListAgentDispatchResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListAgentDispatchResponse | PlainMessage | undefined, b: ListAgentDispatchResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListAgentDispatchResponse, a, b); + } +} + +/** + * @generated from message livekit.AgentDispatch + */ +export class AgentDispatch extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string agent_name = 2; + */ + agentName = ""; + + /** + * @generated from field: string room = 3; + */ + room = ""; + + /** + * @generated from field: string metadata = 4; + */ + metadata = ""; + + /** + * @generated from field: livekit.AgentDispatchState state = 5; + */ + state?: AgentDispatchState; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AgentDispatch"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "agent_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "state", kind: "message", T: AgentDispatchState }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AgentDispatch { + return new AgentDispatch().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AgentDispatch { + return new AgentDispatch().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AgentDispatch { + return new AgentDispatch().fromJsonString(jsonString, options); + } + + static equals(a: AgentDispatch | PlainMessage | undefined, b: AgentDispatch | PlainMessage | undefined): boolean { + return proto3.util.equals(AgentDispatch, a, b); + } +} + +/** + * @generated from message livekit.AgentDispatchState + */ +export class AgentDispatchState extends Message { + /** + * For dispatches of tyoe JT_ROOM, there will be at most 1 job. + * For dispatches of type JT_PUBLISHER, there will be 1 per publisher. + * + * @generated from field: repeated livekit.Job jobs = 1; + */ + jobs: Job[] = []; + + /** + * @generated from field: int64 created_at = 2; + */ + createdAt = protoInt64.zero; + + /** + * @generated from field: int64 deleted_at = 3; + */ + deletedAt = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AgentDispatchState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "jobs", kind: "message", T: Job, repeated: true }, + { no: 2, name: "created_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "deleted_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AgentDispatchState { + return new AgentDispatchState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AgentDispatchState { + return new AgentDispatchState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AgentDispatchState { + return new AgentDispatchState().fromJsonString(jsonString, options); + } + + static equals(a: AgentDispatchState | PlainMessage | undefined, b: AgentDispatchState | PlainMessage | undefined): boolean { + return proto3.util.equals(AgentDispatchState, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_agent_pb.ts b/packages/javascript/src/gen/livekit_agent_pb.ts new file mode 100644 index 00000000..44a483d5 --- /dev/null +++ b/packages/javascript/src/gen/livekit_agent_pb.ts @@ -0,0 +1,1011 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_agent.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { ParticipantInfo, ParticipantPermission, Room, ServerInfo } from "./livekit_models_pb.js"; + +/** + * @generated from enum livekit.JobType + */ +export enum JobType { + /** + * @generated from enum value: JT_ROOM = 0; + */ + JT_ROOM = 0, + + /** + * @generated from enum value: JT_PUBLISHER = 1; + */ + JT_PUBLISHER = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(JobType) +proto3.util.setEnumType(JobType, "livekit.JobType", [ + { no: 0, name: "JT_ROOM" }, + { no: 1, name: "JT_PUBLISHER" }, +]); + +/** + * @generated from enum livekit.WorkerStatus + */ +export enum WorkerStatus { + /** + * @generated from enum value: WS_AVAILABLE = 0; + */ + WS_AVAILABLE = 0, + + /** + * @generated from enum value: WS_FULL = 1; + */ + WS_FULL = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(WorkerStatus) +proto3.util.setEnumType(WorkerStatus, "livekit.WorkerStatus", [ + { no: 0, name: "WS_AVAILABLE" }, + { no: 1, name: "WS_FULL" }, +]); + +/** + * @generated from enum livekit.JobStatus + */ +export enum JobStatus { + /** + * @generated from enum value: JS_PENDING = 0; + */ + JS_PENDING = 0, + + /** + * @generated from enum value: JS_RUNNING = 1; + */ + JS_RUNNING = 1, + + /** + * @generated from enum value: JS_SUCCESS = 2; + */ + JS_SUCCESS = 2, + + /** + * @generated from enum value: JS_FAILED = 3; + */ + JS_FAILED = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(JobStatus) +proto3.util.setEnumType(JobStatus, "livekit.JobStatus", [ + { no: 0, name: "JS_PENDING" }, + { no: 1, name: "JS_RUNNING" }, + { no: 2, name: "JS_SUCCESS" }, + { no: 3, name: "JS_FAILED" }, +]); + +/** + * @generated from message livekit.Job + */ +export class Job extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string dispatch_id = 9; + */ + dispatchId = ""; + + /** + * @generated from field: livekit.JobType type = 2; + */ + type = JobType.JT_ROOM; + + /** + * @generated from field: livekit.Room room = 3; + */ + room?: Room; + + /** + * @generated from field: optional livekit.ParticipantInfo participant = 4; + */ + participant?: ParticipantInfo; + + /** + * @generated from field: string namespace = 5 [deprecated = true]; + * @deprecated + */ + namespace = ""; + + /** + * @generated from field: string metadata = 6; + */ + metadata = ""; + + /** + * @generated from field: string agent_name = 7; + */ + agentName = ""; + + /** + * @generated from field: livekit.JobState state = 8; + */ + state?: JobState; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Job"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "dispatch_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "type", kind: "enum", T: proto3.getEnumType(JobType) }, + { no: 3, name: "room", kind: "message", T: Room }, + { no: 4, name: "participant", kind: "message", T: ParticipantInfo, opt: true }, + { no: 5, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "agent_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "state", kind: "message", T: JobState }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Job { + return new Job().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Job { + return new Job().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Job { + return new Job().fromJsonString(jsonString, options); + } + + static equals(a: Job | PlainMessage | undefined, b: Job | PlainMessage | undefined): boolean { + return proto3.util.equals(Job, a, b); + } +} + +/** + * @generated from message livekit.JobState + */ +export class JobState extends Message { + /** + * @generated from field: livekit.JobStatus status = 1; + */ + status = JobStatus.JS_PENDING; + + /** + * @generated from field: string error = 2; + */ + error = ""; + + /** + * @generated from field: int64 started_at = 3; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 4; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: int64 updated_at = 5; + */ + updatedAt = protoInt64.zero; + + /** + * @generated from field: string participant_identity = 6; + */ + participantIdentity = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.JobState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(JobStatus) }, + { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 4, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 5, name: "updated_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 6, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): JobState { + return new JobState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): JobState { + return new JobState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): JobState { + return new JobState().fromJsonString(jsonString, options); + } + + static equals(a: JobState | PlainMessage | undefined, b: JobState | PlainMessage | undefined): boolean { + return proto3.util.equals(JobState, a, b); + } +} + +/** + * from Worker to Server + * + * @generated from message livekit.WorkerMessage + */ +export class WorkerMessage extends Message { + /** + * @generated from oneof livekit.WorkerMessage.message + */ + message: { + /** + * agent workers need to register themselves with the server first + * + * @generated from field: livekit.RegisterWorkerRequest register = 1; + */ + value: RegisterWorkerRequest; + case: "register"; + } | { + /** + * worker confirms to server that it's available for a job, or declines it + * + * @generated from field: livekit.AvailabilityResponse availability = 2; + */ + value: AvailabilityResponse; + case: "availability"; + } | { + /** + * worker can update its status to the server, including taking itself out of the pool + * + * @generated from field: livekit.UpdateWorkerStatus update_worker = 3; + */ + value: UpdateWorkerStatus; + case: "updateWorker"; + } | { + /** + * job can send status updates to the server, useful for tracking progress + * + * @generated from field: livekit.UpdateJobStatus update_job = 4; + */ + value: UpdateJobStatus; + case: "updateJob"; + } | { + /** + * @generated from field: livekit.WorkerPing ping = 5; + */ + value: WorkerPing; + case: "ping"; + } | { + /** + * @generated from field: livekit.SimulateJobRequest simulate_job = 6; + */ + value: SimulateJobRequest; + case: "simulateJob"; + } | { + /** + * @generated from field: livekit.MigrateJobRequest migrate_job = 7; + */ + value: MigrateJobRequest; + case: "migrateJob"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.WorkerMessage"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "register", kind: "message", T: RegisterWorkerRequest, oneof: "message" }, + { no: 2, name: "availability", kind: "message", T: AvailabilityResponse, oneof: "message" }, + { no: 3, name: "update_worker", kind: "message", T: UpdateWorkerStatus, oneof: "message" }, + { no: 4, name: "update_job", kind: "message", T: UpdateJobStatus, oneof: "message" }, + { no: 5, name: "ping", kind: "message", T: WorkerPing, oneof: "message" }, + { no: 6, name: "simulate_job", kind: "message", T: SimulateJobRequest, oneof: "message" }, + { no: 7, name: "migrate_job", kind: "message", T: MigrateJobRequest, oneof: "message" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): WorkerMessage { + return new WorkerMessage().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): WorkerMessage { + return new WorkerMessage().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): WorkerMessage { + return new WorkerMessage().fromJsonString(jsonString, options); + } + + static equals(a: WorkerMessage | PlainMessage | undefined, b: WorkerMessage | PlainMessage | undefined): boolean { + return proto3.util.equals(WorkerMessage, a, b); + } +} + +/** + * from Server to Worker + * + * @generated from message livekit.ServerMessage + */ +export class ServerMessage extends Message { + /** + * @generated from oneof livekit.ServerMessage.message + */ + message: { + /** + * server confirms the registration, from this moment on, the worker is considered active + * + * @generated from field: livekit.RegisterWorkerResponse register = 1; + */ + value: RegisterWorkerResponse; + case: "register"; + } | { + /** + * server asks worker to confirm availability for a job + * + * @generated from field: livekit.AvailabilityRequest availability = 2; + */ + value: AvailabilityRequest; + case: "availability"; + } | { + /** + * @generated from field: livekit.JobAssignment assignment = 3; + */ + value: JobAssignment; + case: "assignment"; + } | { + /** + * @generated from field: livekit.JobTermination termination = 5; + */ + value: JobTermination; + case: "termination"; + } | { + /** + * @generated from field: livekit.WorkerPong pong = 4; + */ + value: WorkerPong; + case: "pong"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ServerMessage"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "register", kind: "message", T: RegisterWorkerResponse, oneof: "message" }, + { no: 2, name: "availability", kind: "message", T: AvailabilityRequest, oneof: "message" }, + { no: 3, name: "assignment", kind: "message", T: JobAssignment, oneof: "message" }, + { no: 5, name: "termination", kind: "message", T: JobTermination, oneof: "message" }, + { no: 4, name: "pong", kind: "message", T: WorkerPong, oneof: "message" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ServerMessage { + return new ServerMessage().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ServerMessage { + return new ServerMessage().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ServerMessage { + return new ServerMessage().fromJsonString(jsonString, options); + } + + static equals(a: ServerMessage | PlainMessage | undefined, b: ServerMessage | PlainMessage | undefined): boolean { + return proto3.util.equals(ServerMessage, a, b); + } +} + +/** + * @generated from message livekit.SimulateJobRequest + */ +export class SimulateJobRequest extends Message { + /** + * @generated from field: livekit.JobType type = 1; + */ + type = JobType.JT_ROOM; + + /** + * @generated from field: livekit.Room room = 2; + */ + room?: Room; + + /** + * @generated from field: livekit.ParticipantInfo participant = 3; + */ + participant?: ParticipantInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SimulateJobRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(JobType) }, + { no: 2, name: "room", kind: "message", T: Room }, + { no: 3, name: "participant", kind: "message", T: ParticipantInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SimulateJobRequest { + return new SimulateJobRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SimulateJobRequest { + return new SimulateJobRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SimulateJobRequest { + return new SimulateJobRequest().fromJsonString(jsonString, options); + } + + static equals(a: SimulateJobRequest | PlainMessage | undefined, b: SimulateJobRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SimulateJobRequest, a, b); + } +} + +/** + * @generated from message livekit.WorkerPing + */ +export class WorkerPing extends Message { + /** + * @generated from field: int64 timestamp = 1; + */ + timestamp = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.WorkerPing"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): WorkerPing { + return new WorkerPing().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): WorkerPing { + return new WorkerPing().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): WorkerPing { + return new WorkerPing().fromJsonString(jsonString, options); + } + + static equals(a: WorkerPing | PlainMessage | undefined, b: WorkerPing | PlainMessage | undefined): boolean { + return proto3.util.equals(WorkerPing, a, b); + } +} + +/** + * @generated from message livekit.WorkerPong + */ +export class WorkerPong extends Message { + /** + * @generated from field: int64 last_timestamp = 1; + */ + lastTimestamp = protoInt64.zero; + + /** + * @generated from field: int64 timestamp = 2; + */ + timestamp = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.WorkerPong"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "last_timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): WorkerPong { + return new WorkerPong().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): WorkerPong { + return new WorkerPong().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): WorkerPong { + return new WorkerPong().fromJsonString(jsonString, options); + } + + static equals(a: WorkerPong | PlainMessage | undefined, b: WorkerPong | PlainMessage | undefined): boolean { + return proto3.util.equals(WorkerPong, a, b); + } +} + +/** + * @generated from message livekit.RegisterWorkerRequest + */ +export class RegisterWorkerRequest extends Message { + /** + * @generated from field: livekit.JobType type = 1; + */ + type = JobType.JT_ROOM; + + /** + * @generated from field: string agent_name = 8; + */ + agentName = ""; + + /** + * string worker_id = 2; + * + * @generated from field: string version = 3; + */ + version = ""; + + /** + * string name = 4 [deprecated = true]; + * + * @generated from field: uint32 ping_interval = 5; + */ + pingInterval = 0; + + /** + * @generated from field: optional string namespace = 6; + */ + namespace?: string; + + /** + * @generated from field: livekit.ParticipantPermission allowed_permissions = 7; + */ + allowedPermissions?: ParticipantPermission; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RegisterWorkerRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(JobType) }, + { no: 8, name: "agent_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "ping_interval", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 6, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 7, name: "allowed_permissions", kind: "message", T: ParticipantPermission }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RegisterWorkerRequest { + return new RegisterWorkerRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RegisterWorkerRequest { + return new RegisterWorkerRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RegisterWorkerRequest { + return new RegisterWorkerRequest().fromJsonString(jsonString, options); + } + + static equals(a: RegisterWorkerRequest | PlainMessage | undefined, b: RegisterWorkerRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(RegisterWorkerRequest, a, b); + } +} + +/** + * @generated from message livekit.RegisterWorkerResponse + */ +export class RegisterWorkerResponse extends Message { + /** + * @generated from field: string worker_id = 1; + */ + workerId = ""; + + /** + * @generated from field: livekit.ServerInfo server_info = 3; + */ + serverInfo?: ServerInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RegisterWorkerResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "worker_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "server_info", kind: "message", T: ServerInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RegisterWorkerResponse { + return new RegisterWorkerResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RegisterWorkerResponse { + return new RegisterWorkerResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RegisterWorkerResponse { + return new RegisterWorkerResponse().fromJsonString(jsonString, options); + } + + static equals(a: RegisterWorkerResponse | PlainMessage | undefined, b: RegisterWorkerResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(RegisterWorkerResponse, a, b); + } +} + +/** + * @generated from message livekit.MigrateJobRequest + */ +export class MigrateJobRequest extends Message { + /** + * string job_id = 1 [deprecated = true]; + * + * @generated from field: repeated string job_ids = 2; + */ + jobIds: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MigrateJobRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 2, name: "job_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MigrateJobRequest { + return new MigrateJobRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MigrateJobRequest { + return new MigrateJobRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MigrateJobRequest { + return new MigrateJobRequest().fromJsonString(jsonString, options); + } + + static equals(a: MigrateJobRequest | PlainMessage | undefined, b: MigrateJobRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(MigrateJobRequest, a, b); + } +} + +/** + * @generated from message livekit.AvailabilityRequest + */ +export class AvailabilityRequest extends Message { + /** + * @generated from field: livekit.Job job = 1; + */ + job?: Job; + + /** + * True when the job was previously assigned to another worker but has been + * migrated due to different reasons (e.g. worker failure, job migration) + * + * @generated from field: bool resuming = 2; + */ + resuming = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AvailabilityRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "job", kind: "message", T: Job }, + { no: 2, name: "resuming", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AvailabilityRequest { + return new AvailabilityRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AvailabilityRequest { + return new AvailabilityRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AvailabilityRequest { + return new AvailabilityRequest().fromJsonString(jsonString, options); + } + + static equals(a: AvailabilityRequest | PlainMessage | undefined, b: AvailabilityRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(AvailabilityRequest, a, b); + } +} + +/** + * @generated from message livekit.AvailabilityResponse + */ +export class AvailabilityResponse extends Message { + /** + * @generated from field: string job_id = 1; + */ + jobId = ""; + + /** + * @generated from field: bool available = 2; + */ + available = false; + + /** + * @generated from field: bool supports_resume = 3; + */ + supportsResume = false; + + /** + * @generated from field: string participant_name = 4; + */ + participantName = ""; + + /** + * @generated from field: string participant_identity = 5; + */ + participantIdentity = ""; + + /** + * @generated from field: string participant_metadata = 6; + */ + participantMetadata = ""; + + /** + * @generated from field: map participant_attributes = 7; + */ + participantAttributes: { [key: string]: string } = {}; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AvailabilityResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "available", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "supports_resume", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "participant_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "participant_metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "participant_attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AvailabilityResponse { + return new AvailabilityResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AvailabilityResponse { + return new AvailabilityResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AvailabilityResponse { + return new AvailabilityResponse().fromJsonString(jsonString, options); + } + + static equals(a: AvailabilityResponse | PlainMessage | undefined, b: AvailabilityResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(AvailabilityResponse, a, b); + } +} + +/** + * @generated from message livekit.UpdateJobStatus + */ +export class UpdateJobStatus extends Message { + /** + * @generated from field: string job_id = 1; + */ + jobId = ""; + + /** + * The worker can indicate the job end by either specifying SUCCESS or FAILED + * + * @generated from field: livekit.JobStatus status = 2; + */ + status = JobStatus.JS_PENDING; + + /** + * metadata shown on the dashboard, useful for debugging + * + * @generated from field: string error = 3; + */ + error = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateJobStatus"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "status", kind: "enum", T: proto3.getEnumType(JobStatus) }, + { no: 3, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateJobStatus { + return new UpdateJobStatus().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateJobStatus { + return new UpdateJobStatus().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateJobStatus { + return new UpdateJobStatus().fromJsonString(jsonString, options); + } + + static equals(a: UpdateJobStatus | PlainMessage | undefined, b: UpdateJobStatus | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateJobStatus, a, b); + } +} + +/** + * @generated from message livekit.UpdateWorkerStatus + */ +export class UpdateWorkerStatus extends Message { + /** + * @generated from field: optional livekit.WorkerStatus status = 1; + */ + status?: WorkerStatus; + + /** + * optional string metadata = 2 [deprecated=true]; + * + * @generated from field: float load = 3; + */ + load = 0; + + /** + * @generated from field: uint32 job_count = 4; + */ + jobCount = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateWorkerStatus"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(WorkerStatus), opt: true }, + { no: 3, name: "load", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 4, name: "job_count", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateWorkerStatus { + return new UpdateWorkerStatus().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateWorkerStatus { + return new UpdateWorkerStatus().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateWorkerStatus { + return new UpdateWorkerStatus().fromJsonString(jsonString, options); + } + + static equals(a: UpdateWorkerStatus | PlainMessage | undefined, b: UpdateWorkerStatus | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateWorkerStatus, a, b); + } +} + +/** + * @generated from message livekit.JobAssignment + */ +export class JobAssignment extends Message { + /** + * @generated from field: livekit.Job job = 1; + */ + job?: Job; + + /** + * @generated from field: optional string url = 2; + */ + url?: string; + + /** + * @generated from field: string token = 3; + */ + token = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.JobAssignment"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "job", kind: "message", T: Job }, + { no: 2, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 3, name: "token", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): JobAssignment { + return new JobAssignment().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): JobAssignment { + return new JobAssignment().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): JobAssignment { + return new JobAssignment().fromJsonString(jsonString, options); + } + + static equals(a: JobAssignment | PlainMessage | undefined, b: JobAssignment | PlainMessage | undefined): boolean { + return proto3.util.equals(JobAssignment, a, b); + } +} + +/** + * @generated from message livekit.JobTermination + */ +export class JobTermination extends Message { + /** + * @generated from field: string job_id = 1; + */ + jobId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.JobTermination"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): JobTermination { + return new JobTermination().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): JobTermination { + return new JobTermination().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): JobTermination { + return new JobTermination().fromJsonString(jsonString, options); + } + + static equals(a: JobTermination | PlainMessage | undefined, b: JobTermination | PlainMessage | undefined): boolean { + return proto3.util.equals(JobTermination, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_analytics_pb.ts b/packages/javascript/src/gen/livekit_analytics_pb.ts new file mode 100644 index 00000000..26ad1b90 --- /dev/null +++ b/packages/javascript/src/gen/livekit_analytics_pb.ts @@ -0,0 +1,1146 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_analytics.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf"; +import { ClientInfo, ParticipantInfo, ParticipantInfo_State, ReconnectReason, Room, RTPStats, TrackInfo, VideoQuality } from "./livekit_models_pb.js"; +import { EgressInfo } from "./livekit_egress_pb.js"; +import { IngressInfo } from "./livekit_ingress_pb.js"; +import { SIPCallInfo, SIPDispatchRuleInfo, SIPInboundTrunkInfo, SIPOutboundTrunkInfo } from "./livekit_sip_pb.js"; + +/** + * @generated from enum livekit.StreamType + */ +export enum StreamType { + /** + * @generated from enum value: UPSTREAM = 0; + */ + UPSTREAM = 0, + + /** + * @generated from enum value: DOWNSTREAM = 1; + */ + DOWNSTREAM = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(StreamType) +proto3.util.setEnumType(StreamType, "livekit.StreamType", [ + { no: 0, name: "UPSTREAM" }, + { no: 1, name: "DOWNSTREAM" }, +]); + +/** + * @generated from enum livekit.AnalyticsEventType + */ +export enum AnalyticsEventType { + /** + * @generated from enum value: ROOM_CREATED = 0; + */ + ROOM_CREATED = 0, + + /** + * @generated from enum value: ROOM_ENDED = 1; + */ + ROOM_ENDED = 1, + + /** + * @generated from enum value: PARTICIPANT_JOINED = 2; + */ + PARTICIPANT_JOINED = 2, + + /** + * @generated from enum value: PARTICIPANT_LEFT = 3; + */ + PARTICIPANT_LEFT = 3, + + /** + * @generated from enum value: TRACK_PUBLISHED = 4; + */ + TRACK_PUBLISHED = 4, + + /** + * @generated from enum value: TRACK_PUBLISH_REQUESTED = 20; + */ + TRACK_PUBLISH_REQUESTED = 20, + + /** + * @generated from enum value: TRACK_UNPUBLISHED = 5; + */ + TRACK_UNPUBLISHED = 5, + + /** + * @generated from enum value: TRACK_SUBSCRIBED = 6; + */ + TRACK_SUBSCRIBED = 6, + + /** + * @generated from enum value: TRACK_SUBSCRIBE_REQUESTED = 21; + */ + TRACK_SUBSCRIBE_REQUESTED = 21, + + /** + * @generated from enum value: TRACK_SUBSCRIBE_FAILED = 25; + */ + TRACK_SUBSCRIBE_FAILED = 25, + + /** + * @generated from enum value: TRACK_UNSUBSCRIBED = 7; + */ + TRACK_UNSUBSCRIBED = 7, + + /** + * @generated from enum value: TRACK_PUBLISHED_UPDATE = 10; + */ + TRACK_PUBLISHED_UPDATE = 10, + + /** + * @generated from enum value: TRACK_MUTED = 23; + */ + TRACK_MUTED = 23, + + /** + * @generated from enum value: TRACK_UNMUTED = 24; + */ + TRACK_UNMUTED = 24, + + /** + * @generated from enum value: TRACK_PUBLISH_STATS = 26; + */ + TRACK_PUBLISH_STATS = 26, + + /** + * @generated from enum value: TRACK_SUBSCRIBE_STATS = 27; + */ + TRACK_SUBSCRIBE_STATS = 27, + + /** + * @generated from enum value: PARTICIPANT_ACTIVE = 11; + */ + PARTICIPANT_ACTIVE = 11, + + /** + * @generated from enum value: PARTICIPANT_RESUMED = 22; + */ + PARTICIPANT_RESUMED = 22, + + /** + * @generated from enum value: EGRESS_STARTED = 12; + */ + EGRESS_STARTED = 12, + + /** + * @generated from enum value: EGRESS_ENDED = 13; + */ + EGRESS_ENDED = 13, + + /** + * @generated from enum value: EGRESS_UPDATED = 28; + */ + EGRESS_UPDATED = 28, + + /** + * @generated from enum value: TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY = 14; + */ + TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY = 14, + + /** + * @generated from enum value: RECONNECTED = 15; + */ + RECONNECTED = 15, + + /** + * @generated from enum value: INGRESS_CREATED = 18; + */ + INGRESS_CREATED = 18, + + /** + * @generated from enum value: INGRESS_DELETED = 19; + */ + INGRESS_DELETED = 19, + + /** + * @generated from enum value: INGRESS_STARTED = 16; + */ + INGRESS_STARTED = 16, + + /** + * @generated from enum value: INGRESS_ENDED = 17; + */ + INGRESS_ENDED = 17, + + /** + * @generated from enum value: INGRESS_UPDATED = 29; + */ + INGRESS_UPDATED = 29, + + /** + * @generated from enum value: SIP_INBOUND_TRUNK_CREATED = 30; + */ + SIP_INBOUND_TRUNK_CREATED = 30, + + /** + * @generated from enum value: SIP_INBOUND_TRUNK_DELETED = 31; + */ + SIP_INBOUND_TRUNK_DELETED = 31, + + /** + * @generated from enum value: SIP_OUTBOUND_TRUNK_CREATED = 32; + */ + SIP_OUTBOUND_TRUNK_CREATED = 32, + + /** + * @generated from enum value: SIP_OUTBOUND_TRUNK_DELETED = 33; + */ + SIP_OUTBOUND_TRUNK_DELETED = 33, + + /** + * @generated from enum value: SIP_DISPATCH_RULE_CREATED = 34; + */ + SIP_DISPATCH_RULE_CREATED = 34, + + /** + * @generated from enum value: SIP_DISPATCH_RULE_DELETED = 35; + */ + SIP_DISPATCH_RULE_DELETED = 35, + + /** + * @generated from enum value: SIP_PARTICIPANT_CREATED = 36; + */ + SIP_PARTICIPANT_CREATED = 36, + + /** + * @generated from enum value: SIP_CALL_INCOMING = 37; + */ + SIP_CALL_INCOMING = 37, + + /** + * @generated from enum value: SIP_CALL_STARTED = 38; + */ + SIP_CALL_STARTED = 38, + + /** + * @generated from enum value: SIP_CALL_ENDED = 39; + */ + SIP_CALL_ENDED = 39, +} +// Retrieve enum metadata with: proto3.getEnumType(AnalyticsEventType) +proto3.util.setEnumType(AnalyticsEventType, "livekit.AnalyticsEventType", [ + { no: 0, name: "ROOM_CREATED" }, + { no: 1, name: "ROOM_ENDED" }, + { no: 2, name: "PARTICIPANT_JOINED" }, + { no: 3, name: "PARTICIPANT_LEFT" }, + { no: 4, name: "TRACK_PUBLISHED" }, + { no: 20, name: "TRACK_PUBLISH_REQUESTED" }, + { no: 5, name: "TRACK_UNPUBLISHED" }, + { no: 6, name: "TRACK_SUBSCRIBED" }, + { no: 21, name: "TRACK_SUBSCRIBE_REQUESTED" }, + { no: 25, name: "TRACK_SUBSCRIBE_FAILED" }, + { no: 7, name: "TRACK_UNSUBSCRIBED" }, + { no: 10, name: "TRACK_PUBLISHED_UPDATE" }, + { no: 23, name: "TRACK_MUTED" }, + { no: 24, name: "TRACK_UNMUTED" }, + { no: 26, name: "TRACK_PUBLISH_STATS" }, + { no: 27, name: "TRACK_SUBSCRIBE_STATS" }, + { no: 11, name: "PARTICIPANT_ACTIVE" }, + { no: 22, name: "PARTICIPANT_RESUMED" }, + { no: 12, name: "EGRESS_STARTED" }, + { no: 13, name: "EGRESS_ENDED" }, + { no: 28, name: "EGRESS_UPDATED" }, + { no: 14, name: "TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY" }, + { no: 15, name: "RECONNECTED" }, + { no: 18, name: "INGRESS_CREATED" }, + { no: 19, name: "INGRESS_DELETED" }, + { no: 16, name: "INGRESS_STARTED" }, + { no: 17, name: "INGRESS_ENDED" }, + { no: 29, name: "INGRESS_UPDATED" }, + { no: 30, name: "SIP_INBOUND_TRUNK_CREATED" }, + { no: 31, name: "SIP_INBOUND_TRUNK_DELETED" }, + { no: 32, name: "SIP_OUTBOUND_TRUNK_CREATED" }, + { no: 33, name: "SIP_OUTBOUND_TRUNK_DELETED" }, + { no: 34, name: "SIP_DISPATCH_RULE_CREATED" }, + { no: 35, name: "SIP_DISPATCH_RULE_DELETED" }, + { no: 36, name: "SIP_PARTICIPANT_CREATED" }, + { no: 37, name: "SIP_CALL_INCOMING" }, + { no: 38, name: "SIP_CALL_STARTED" }, + { no: 39, name: "SIP_CALL_ENDED" }, +]); + +/** + * @generated from message livekit.AnalyticsVideoLayer + */ +export class AnalyticsVideoLayer extends Message { + /** + * @generated from field: int32 layer = 1; + */ + layer = 0; + + /** + * @generated from field: uint32 packets = 2; + */ + packets = 0; + + /** + * @generated from field: uint64 bytes = 3; + */ + bytes = protoInt64.zero; + + /** + * @generated from field: uint32 frames = 4; + */ + frames = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsVideoLayer"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "layer", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 2, name: "packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 4, name: "frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsVideoLayer { + return new AnalyticsVideoLayer().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsVideoLayer { + return new AnalyticsVideoLayer().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsVideoLayer { + return new AnalyticsVideoLayer().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsVideoLayer | PlainMessage | undefined, b: AnalyticsVideoLayer | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsVideoLayer, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsStream + */ +export class AnalyticsStream extends Message { + /** + * @generated from field: uint32 ssrc = 1; + */ + ssrc = 0; + + /** + * @generated from field: uint32 primary_packets = 2; + */ + primaryPackets = 0; + + /** + * @generated from field: uint64 primary_bytes = 3; + */ + primaryBytes = protoInt64.zero; + + /** + * @generated from field: uint32 retransmit_packets = 4; + */ + retransmitPackets = 0; + + /** + * @generated from field: uint64 retransmit_bytes = 5; + */ + retransmitBytes = protoInt64.zero; + + /** + * @generated from field: uint32 padding_packets = 6; + */ + paddingPackets = 0; + + /** + * @generated from field: uint64 padding_bytes = 7; + */ + paddingBytes = protoInt64.zero; + + /** + * @generated from field: uint32 packets_lost = 8; + */ + packetsLost = 0; + + /** + * @generated from field: uint32 frames = 9; + */ + frames = 0; + + /** + * @generated from field: uint32 rtt = 10; + */ + rtt = 0; + + /** + * @generated from field: uint32 jitter = 11; + */ + jitter = 0; + + /** + * @generated from field: uint32 nacks = 12; + */ + nacks = 0; + + /** + * @generated from field: uint32 plis = 13; + */ + plis = 0; + + /** + * @generated from field: uint32 firs = 14; + */ + firs = 0; + + /** + * @generated from field: repeated livekit.AnalyticsVideoLayer video_layers = 15; + */ + videoLayers: AnalyticsVideoLayer[] = []; + + /** + * @generated from field: google.protobuf.Timestamp start_time = 17; + */ + startTime?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp end_time = 18; + */ + endTime?: Timestamp; + + /** + * @generated from field: uint32 packets_out_of_order = 19; + */ + packetsOutOfOrder = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsStream"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ssrc", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "primary_packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "primary_bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 4, name: "retransmit_packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "retransmit_bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 6, name: "padding_packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 7, name: "padding_bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 8, name: "packets_lost", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 9, name: "frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 10, name: "rtt", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 11, name: "jitter", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 12, name: "nacks", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 13, name: "plis", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 14, name: "firs", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 15, name: "video_layers", kind: "message", T: AnalyticsVideoLayer, repeated: true }, + { no: 17, name: "start_time", kind: "message", T: Timestamp }, + { no: 18, name: "end_time", kind: "message", T: Timestamp }, + { no: 19, name: "packets_out_of_order", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsStream { + return new AnalyticsStream().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsStream { + return new AnalyticsStream().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsStream { + return new AnalyticsStream().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsStream | PlainMessage | undefined, b: AnalyticsStream | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsStream, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsStat + */ +export class AnalyticsStat extends Message { + /** + * unique id for this stat + * + * @generated from field: string id = 14; + */ + id = ""; + + /** + * @generated from field: string analytics_key = 1; + */ + analyticsKey = ""; + + /** + * @generated from field: livekit.StreamType kind = 2; + */ + kind = StreamType.UPSTREAM; + + /** + * @generated from field: google.protobuf.Timestamp time_stamp = 3; + */ + timeStamp?: Timestamp; + + /** + * @generated from field: string node = 4; + */ + node = ""; + + /** + * @generated from field: string room_id = 5; + */ + roomId = ""; + + /** + * @generated from field: string room_name = 6; + */ + roomName = ""; + + /** + * @generated from field: string participant_id = 7; + */ + participantId = ""; + + /** + * @generated from field: string track_id = 8; + */ + trackId = ""; + + /** + * average score + * + * @generated from field: float score = 9; + */ + score = 0; + + /** + * @generated from field: repeated livekit.AnalyticsStream streams = 10; + */ + streams: AnalyticsStream[] = []; + + /** + * @generated from field: string mime = 11; + */ + mime = ""; + + /** + * @generated from field: float min_score = 12; + */ + minScore = 0; + + /** + * @generated from field: float median_score = 13; + */ + medianScore = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsStat"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 14, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 1, name: "analytics_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "kind", kind: "enum", T: proto3.getEnumType(StreamType) }, + { no: 3, name: "time_stamp", kind: "message", T: Timestamp }, + { no: 4, name: "node", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "room_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "participant_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "score", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 10, name: "streams", kind: "message", T: AnalyticsStream, repeated: true }, + { no: 11, name: "mime", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 12, name: "min_score", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 13, name: "median_score", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsStat { + return new AnalyticsStat().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsStat { + return new AnalyticsStat().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsStat { + return new AnalyticsStat().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsStat | PlainMessage | undefined, b: AnalyticsStat | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsStat, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsStats + */ +export class AnalyticsStats extends Message { + /** + * @generated from field: repeated livekit.AnalyticsStat stats = 1; + */ + stats: AnalyticsStat[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsStats"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "stats", kind: "message", T: AnalyticsStat, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsStats { + return new AnalyticsStats().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsStats { + return new AnalyticsStats().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsStats { + return new AnalyticsStats().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsStats | PlainMessage | undefined, b: AnalyticsStats | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsStats, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsClientMeta + */ +export class AnalyticsClientMeta extends Message { + /** + * @generated from field: string region = 1; + */ + region = ""; + + /** + * @generated from field: string node = 2; + */ + node = ""; + + /** + * @generated from field: string client_addr = 3; + */ + clientAddr = ""; + + /** + * @generated from field: uint32 client_connect_time = 4; + */ + clientConnectTime = 0; + + /** + * udp, tcp, turn + * + * @generated from field: string connection_type = 5; + */ + connectionType = ""; + + /** + * @generated from field: livekit.ReconnectReason reconnect_reason = 6; + */ + reconnectReason = ReconnectReason.RR_UNKNOWN; + + /** + * @generated from field: optional string geo_hash = 7; + */ + geoHash?: string; + + /** + * @generated from field: optional string country = 8; + */ + country?: string; + + /** + * @generated from field: optional uint32 isp_asn = 9; + */ + ispAsn?: number; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsClientMeta"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "node", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "client_addr", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "client_connect_time", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "connection_type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "reconnect_reason", kind: "enum", T: proto3.getEnumType(ReconnectReason) }, + { no: 7, name: "geo_hash", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 8, name: "country", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 9, name: "isp_asn", kind: "scalar", T: 13 /* ScalarType.UINT32 */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsClientMeta { + return new AnalyticsClientMeta().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsClientMeta { + return new AnalyticsClientMeta().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsClientMeta { + return new AnalyticsClientMeta().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsClientMeta | PlainMessage | undefined, b: AnalyticsClientMeta | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsClientMeta, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsEvent + */ +export class AnalyticsEvent extends Message { + /** + * unique id for this event + * + * @generated from field: string id = 25; + */ + id = ""; + + /** + * @generated from field: livekit.AnalyticsEventType type = 1; + */ + type = AnalyticsEventType.ROOM_CREATED; + + /** + * @generated from field: google.protobuf.Timestamp timestamp = 2; + */ + timestamp?: Timestamp; + + /** + * @generated from field: string room_id = 3; + */ + roomId = ""; + + /** + * @generated from field: livekit.Room room = 4; + */ + room?: Room; + + /** + * @generated from field: string participant_id = 5; + */ + participantId = ""; + + /** + * @generated from field: livekit.ParticipantInfo participant = 6; + */ + participant?: ParticipantInfo; + + /** + * @generated from field: string track_id = 7; + */ + trackId = ""; + + /** + * @generated from field: livekit.TrackInfo track = 8; + */ + track?: TrackInfo; + + /** + * @generated from field: string analytics_key = 10; + */ + analyticsKey = ""; + + /** + * @generated from field: livekit.ClientInfo client_info = 11; + */ + clientInfo?: ClientInfo; + + /** + * @generated from field: livekit.AnalyticsClientMeta client_meta = 12; + */ + clientMeta?: AnalyticsClientMeta; + + /** + * @generated from field: string egress_id = 13; + */ + egressId = ""; + + /** + * @generated from field: string ingress_id = 19; + */ + ingressId = ""; + + /** + * @generated from field: livekit.VideoQuality max_subscribed_video_quality = 14; + */ + maxSubscribedVideoQuality = VideoQuality.LOW; + + /** + * @generated from field: livekit.ParticipantInfo publisher = 15; + */ + publisher?: ParticipantInfo; + + /** + * @generated from field: string mime = 16; + */ + mime = ""; + + /** + * @generated from field: livekit.EgressInfo egress = 17; + */ + egress?: EgressInfo; + + /** + * @generated from field: livekit.IngressInfo ingress = 18; + */ + ingress?: IngressInfo; + + /** + * @generated from field: string error = 20; + */ + error = ""; + + /** + * @generated from field: livekit.RTPStats rtp_stats = 21; + */ + rtpStats?: RTPStats; + + /** + * @generated from field: int32 video_layer = 22; + */ + videoLayer = 0; + + /** + * @generated from field: string node_id = 24; + */ + nodeId = ""; + + /** + * @generated from field: string sip_call_id = 26; + */ + sipCallId = ""; + + /** + * @generated from field: livekit.SIPCallInfo sip_call = 27; + */ + sipCall?: SIPCallInfo; + + /** + * @generated from field: string sip_trunk_id = 28; + */ + sipTrunkId = ""; + + /** + * @generated from field: livekit.SIPInboundTrunkInfo sip_inbound_trunk = 29; + */ + sipInboundTrunk?: SIPInboundTrunkInfo; + + /** + * @generated from field: livekit.SIPOutboundTrunkInfo sip_outbound_trunk = 30; + */ + sipOutboundTrunk?: SIPOutboundTrunkInfo; + + /** + * @generated from field: string sip_dispatch_rule_id = 31; + */ + sipDispatchRuleId = ""; + + /** + * @generated from field: livekit.SIPDispatchRuleInfo sip_dispatch_rule = 32; + */ + sipDispatchRule?: SIPDispatchRuleInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsEvent"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 25, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(AnalyticsEventType) }, + { no: 2, name: "timestamp", kind: "message", T: Timestamp }, + { no: 3, name: "room_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "room", kind: "message", T: Room }, + { no: 5, name: "participant_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "participant", kind: "message", T: ParticipantInfo }, + { no: 7, name: "track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "track", kind: "message", T: TrackInfo }, + { no: 10, name: "analytics_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "client_info", kind: "message", T: ClientInfo }, + { no: 12, name: "client_meta", kind: "message", T: AnalyticsClientMeta }, + { no: 13, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 19, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 14, name: "max_subscribed_video_quality", kind: "enum", T: proto3.getEnumType(VideoQuality) }, + { no: 15, name: "publisher", kind: "message", T: ParticipantInfo }, + { no: 16, name: "mime", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 17, name: "egress", kind: "message", T: EgressInfo }, + { no: 18, name: "ingress", kind: "message", T: IngressInfo }, + { no: 20, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 21, name: "rtp_stats", kind: "message", T: RTPStats }, + { no: 22, name: "video_layer", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 24, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 26, name: "sip_call_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 27, name: "sip_call", kind: "message", T: SIPCallInfo }, + { no: 28, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 29, name: "sip_inbound_trunk", kind: "message", T: SIPInboundTrunkInfo }, + { no: 30, name: "sip_outbound_trunk", kind: "message", T: SIPOutboundTrunkInfo }, + { no: 31, name: "sip_dispatch_rule_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 32, name: "sip_dispatch_rule", kind: "message", T: SIPDispatchRuleInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsEvent { + return new AnalyticsEvent().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsEvent { + return new AnalyticsEvent().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsEvent { + return new AnalyticsEvent().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsEvent | PlainMessage | undefined, b: AnalyticsEvent | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsEvent, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsEvents + */ +export class AnalyticsEvents extends Message { + /** + * @generated from field: repeated livekit.AnalyticsEvent events = 1; + */ + events: AnalyticsEvent[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsEvents"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "events", kind: "message", T: AnalyticsEvent, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsEvents { + return new AnalyticsEvents().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsEvents { + return new AnalyticsEvents().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsEvents { + return new AnalyticsEvents().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsEvents | PlainMessage | undefined, b: AnalyticsEvents | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsEvents, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsRoomParticipant + */ +export class AnalyticsRoomParticipant extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * @generated from field: string name = 3; + */ + name = ""; + + /** + * @generated from field: livekit.ParticipantInfo.State state = 4; + */ + state = ParticipantInfo_State.JOINING; + + /** + * @generated from field: google.protobuf.Timestamp joined_at = 5; + */ + joinedAt?: Timestamp; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsRoomParticipant"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "state", kind: "enum", T: proto3.getEnumType(ParticipantInfo_State) }, + { no: 5, name: "joined_at", kind: "message", T: Timestamp }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsRoomParticipant { + return new AnalyticsRoomParticipant().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsRoomParticipant { + return new AnalyticsRoomParticipant().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsRoomParticipant { + return new AnalyticsRoomParticipant().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsRoomParticipant | PlainMessage | undefined, b: AnalyticsRoomParticipant | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsRoomParticipant, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsRoom + */ +export class AnalyticsRoom extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * @generated from field: string project_id = 5; + */ + projectId = ""; + + /** + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt?: Timestamp; + + /** + * @generated from field: repeated livekit.AnalyticsRoomParticipant participants = 4; + */ + participants: AnalyticsRoomParticipant[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsRoom"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "project_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "created_at", kind: "message", T: Timestamp }, + { no: 4, name: "participants", kind: "message", T: AnalyticsRoomParticipant, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsRoom { + return new AnalyticsRoom().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsRoom { + return new AnalyticsRoom().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsRoom { + return new AnalyticsRoom().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsRoom | PlainMessage | undefined, b: AnalyticsRoom | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsRoom, a, b); + } +} + +/** + * @generated from message livekit.AnalyticsNodeRooms + */ +export class AnalyticsNodeRooms extends Message { + /** + * @generated from field: string node_id = 1; + */ + nodeId = ""; + + /** + * @generated from field: uint64 sequence_number = 2; + */ + sequenceNumber = protoInt64.zero; + + /** + * @generated from field: google.protobuf.Timestamp timestamp = 3; + */ + timestamp?: Timestamp; + + /** + * @generated from field: repeated livekit.AnalyticsRoom rooms = 4; + */ + rooms: AnalyticsRoom[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AnalyticsNodeRooms"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "sequence_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 3, name: "timestamp", kind: "message", T: Timestamp }, + { no: 4, name: "rooms", kind: "message", T: AnalyticsRoom, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AnalyticsNodeRooms { + return new AnalyticsNodeRooms().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AnalyticsNodeRooms { + return new AnalyticsNodeRooms().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AnalyticsNodeRooms { + return new AnalyticsNodeRooms().fromJsonString(jsonString, options); + } + + static equals(a: AnalyticsNodeRooms | PlainMessage | undefined, b: AnalyticsNodeRooms | PlainMessage | undefined): boolean { + return proto3.util.equals(AnalyticsNodeRooms, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_egress_pb.ts b/packages/javascript/src/gen/livekit_egress_pb.ts new file mode 100644 index 00000000..d0ab8006 --- /dev/null +++ b/packages/javascript/src/gen/livekit_egress_pb.ts @@ -0,0 +1,2654 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_egress.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { AudioCodec, ImageCodec, VideoCodec } from "./livekit_models_pb.js"; + +/** + * @generated from enum livekit.EncodedFileType + */ +export enum EncodedFileType { + /** + * file type chosen based on codecs + * + * @generated from enum value: DEFAULT_FILETYPE = 0; + */ + DEFAULT_FILETYPE = 0, + + /** + * @generated from enum value: MP4 = 1; + */ + MP4 = 1, + + /** + * @generated from enum value: OGG = 2; + */ + OGG = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(EncodedFileType) +proto3.util.setEnumType(EncodedFileType, "livekit.EncodedFileType", [ + { no: 0, name: "DEFAULT_FILETYPE" }, + { no: 1, name: "MP4" }, + { no: 2, name: "OGG" }, +]); + +/** + * @generated from enum livekit.SegmentedFileProtocol + */ +export enum SegmentedFileProtocol { + /** + * @generated from enum value: DEFAULT_SEGMENTED_FILE_PROTOCOL = 0; + */ + DEFAULT_SEGMENTED_FILE_PROTOCOL = 0, + + /** + * @generated from enum value: HLS_PROTOCOL = 1; + */ + HLS_PROTOCOL = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(SegmentedFileProtocol) +proto3.util.setEnumType(SegmentedFileProtocol, "livekit.SegmentedFileProtocol", [ + { no: 0, name: "DEFAULT_SEGMENTED_FILE_PROTOCOL" }, + { no: 1, name: "HLS_PROTOCOL" }, +]); + +/** + * @generated from enum livekit.SegmentedFileSuffix + */ +export enum SegmentedFileSuffix { + /** + * @generated from enum value: INDEX = 0; + */ + INDEX = 0, + + /** + * @generated from enum value: TIMESTAMP = 1; + */ + TIMESTAMP = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(SegmentedFileSuffix) +proto3.util.setEnumType(SegmentedFileSuffix, "livekit.SegmentedFileSuffix", [ + { no: 0, name: "INDEX" }, + { no: 1, name: "TIMESTAMP" }, +]); + +/** + * @generated from enum livekit.ImageFileSuffix + */ +export enum ImageFileSuffix { + /** + * @generated from enum value: IMAGE_SUFFIX_INDEX = 0; + */ + IMAGE_SUFFIX_INDEX = 0, + + /** + * @generated from enum value: IMAGE_SUFFIX_TIMESTAMP = 1; + */ + IMAGE_SUFFIX_TIMESTAMP = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(ImageFileSuffix) +proto3.util.setEnumType(ImageFileSuffix, "livekit.ImageFileSuffix", [ + { no: 0, name: "IMAGE_SUFFIX_INDEX" }, + { no: 1, name: "IMAGE_SUFFIX_TIMESTAMP" }, +]); + +/** + * @generated from enum livekit.StreamProtocol + */ +export enum StreamProtocol { + /** + * protocol chosen based on urls + * + * @generated from enum value: DEFAULT_PROTOCOL = 0; + */ + DEFAULT_PROTOCOL = 0, + + /** + * @generated from enum value: RTMP = 1; + */ + RTMP = 1, + + /** + * @generated from enum value: SRT = 2; + */ + SRT = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(StreamProtocol) +proto3.util.setEnumType(StreamProtocol, "livekit.StreamProtocol", [ + { no: 0, name: "DEFAULT_PROTOCOL" }, + { no: 1, name: "RTMP" }, + { no: 2, name: "SRT" }, +]); + +/** + * @generated from enum livekit.EncodingOptionsPreset + */ +export enum EncodingOptionsPreset { + /** + * 1280x720, 30fps, 3000kpbs, H.264_MAIN / OPUS + * + * @generated from enum value: H264_720P_30 = 0; + */ + H264_720P_30 = 0, + + /** + * 1280x720, 60fps, 4500kbps, H.264_MAIN / OPUS + * + * @generated from enum value: H264_720P_60 = 1; + */ + H264_720P_60 = 1, + + /** + * 1920x1080, 30fps, 4500kbps, H.264_MAIN / OPUS + * + * @generated from enum value: H264_1080P_30 = 2; + */ + H264_1080P_30 = 2, + + /** + * 1920x1080, 60fps, 6000kbps, H.264_MAIN / OPUS + * + * @generated from enum value: H264_1080P_60 = 3; + */ + H264_1080P_60 = 3, + + /** + * 720x1280, 30fps, 3000kpbs, H.264_MAIN / OPUS + * + * @generated from enum value: PORTRAIT_H264_720P_30 = 4; + */ + PORTRAIT_H264_720P_30 = 4, + + /** + * 720x1280, 60fps, 4500kbps, H.264_MAIN / OPUS + * + * @generated from enum value: PORTRAIT_H264_720P_60 = 5; + */ + PORTRAIT_H264_720P_60 = 5, + + /** + * 1080x1920, 30fps, 4500kbps, H.264_MAIN / OPUS + * + * @generated from enum value: PORTRAIT_H264_1080P_30 = 6; + */ + PORTRAIT_H264_1080P_30 = 6, + + /** + * 1080x1920, 60fps, 6000kbps, H.264_MAIN / OPUS + * + * @generated from enum value: PORTRAIT_H264_1080P_60 = 7; + */ + PORTRAIT_H264_1080P_60 = 7, +} +// Retrieve enum metadata with: proto3.getEnumType(EncodingOptionsPreset) +proto3.util.setEnumType(EncodingOptionsPreset, "livekit.EncodingOptionsPreset", [ + { no: 0, name: "H264_720P_30" }, + { no: 1, name: "H264_720P_60" }, + { no: 2, name: "H264_1080P_30" }, + { no: 3, name: "H264_1080P_60" }, + { no: 4, name: "PORTRAIT_H264_720P_30" }, + { no: 5, name: "PORTRAIT_H264_720P_60" }, + { no: 6, name: "PORTRAIT_H264_1080P_30" }, + { no: 7, name: "PORTRAIT_H264_1080P_60" }, +]); + +/** + * @generated from enum livekit.EgressStatus + */ +export enum EgressStatus { + /** + * @generated from enum value: EGRESS_STARTING = 0; + */ + EGRESS_STARTING = 0, + + /** + * @generated from enum value: EGRESS_ACTIVE = 1; + */ + EGRESS_ACTIVE = 1, + + /** + * @generated from enum value: EGRESS_ENDING = 2; + */ + EGRESS_ENDING = 2, + + /** + * @generated from enum value: EGRESS_COMPLETE = 3; + */ + EGRESS_COMPLETE = 3, + + /** + * @generated from enum value: EGRESS_FAILED = 4; + */ + EGRESS_FAILED = 4, + + /** + * @generated from enum value: EGRESS_ABORTED = 5; + */ + EGRESS_ABORTED = 5, + + /** + * @generated from enum value: EGRESS_LIMIT_REACHED = 6; + */ + EGRESS_LIMIT_REACHED = 6, +} +// Retrieve enum metadata with: proto3.getEnumType(EgressStatus) +proto3.util.setEnumType(EgressStatus, "livekit.EgressStatus", [ + { no: 0, name: "EGRESS_STARTING" }, + { no: 1, name: "EGRESS_ACTIVE" }, + { no: 2, name: "EGRESS_ENDING" }, + { no: 3, name: "EGRESS_COMPLETE" }, + { no: 4, name: "EGRESS_FAILED" }, + { no: 5, name: "EGRESS_ABORTED" }, + { no: 6, name: "EGRESS_LIMIT_REACHED" }, +]); + +/** + * composite using a web browser + * + * @generated from message livekit.RoomCompositeEgressRequest + */ +export class RoomCompositeEgressRequest extends Message { + /** + * required + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * (optional) + * + * @generated from field: string layout = 2; + */ + layout = ""; + + /** + * (default false) + * + * @generated from field: bool audio_only = 3; + */ + audioOnly = false; + + /** + * (default false) + * + * @generated from field: bool video_only = 4; + */ + videoOnly = false; + + /** + * template base url (default https://recorder.livekit.io) + * + * @generated from field: string custom_base_url = 5; + */ + customBaseUrl = ""; + + /** + * deprecated (use _output fields) + * + * @generated from oneof livekit.RoomCompositeEgressRequest.output + */ + output: { + /** + * @generated from field: livekit.EncodedFileOutput file = 6 [deprecated = true]; + * @deprecated + */ + value: EncodedFileOutput; + case: "file"; + } | { + /** + * @generated from field: livekit.StreamOutput stream = 7 [deprecated = true]; + * @deprecated + */ + value: StreamOutput; + case: "stream"; + } | { + /** + * @generated from field: livekit.SegmentedFileOutput segments = 10 [deprecated = true]; + * @deprecated + */ + value: SegmentedFileOutput; + case: "segments"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from oneof livekit.RoomCompositeEgressRequest.options + */ + options: { + /** + * (default H264_720P_30) + * + * @generated from field: livekit.EncodingOptionsPreset preset = 8; + */ + value: EncodingOptionsPreset; + case: "preset"; + } | { + /** + * (optional) + * + * @generated from field: livekit.EncodingOptions advanced = 9; + */ + value: EncodingOptions; + case: "advanced"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.EncodedFileOutput file_outputs = 11; + */ + fileOutputs: EncodedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.StreamOutput stream_outputs = 12; + */ + streamOutputs: StreamOutput[] = []; + + /** + * @generated from field: repeated livekit.SegmentedFileOutput segment_outputs = 13; + */ + segmentOutputs: SegmentedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.ImageOutput image_outputs = 14; + */ + imageOutputs: ImageOutput[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomCompositeEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "layout", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "audio_only", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "video_only", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 5, name: "custom_base_url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "file", kind: "message", T: EncodedFileOutput, oneof: "output" }, + { no: 7, name: "stream", kind: "message", T: StreamOutput, oneof: "output" }, + { no: 10, name: "segments", kind: "message", T: SegmentedFileOutput, oneof: "output" }, + { no: 8, name: "preset", kind: "enum", T: proto3.getEnumType(EncodingOptionsPreset), oneof: "options" }, + { no: 9, name: "advanced", kind: "message", T: EncodingOptions, oneof: "options" }, + { no: 11, name: "file_outputs", kind: "message", T: EncodedFileOutput, repeated: true }, + { no: 12, name: "stream_outputs", kind: "message", T: StreamOutput, repeated: true }, + { no: 13, name: "segment_outputs", kind: "message", T: SegmentedFileOutput, repeated: true }, + { no: 14, name: "image_outputs", kind: "message", T: ImageOutput, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomCompositeEgressRequest { + return new RoomCompositeEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomCompositeEgressRequest { + return new RoomCompositeEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomCompositeEgressRequest { + return new RoomCompositeEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: RoomCompositeEgressRequest | PlainMessage | undefined, b: RoomCompositeEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomCompositeEgressRequest, a, b); + } +} + +/** + * record any website + * + * @generated from message livekit.WebEgressRequest + */ +export class WebEgressRequest extends Message { + /** + * @generated from field: string url = 1; + */ + url = ""; + + /** + * @generated from field: bool audio_only = 2; + */ + audioOnly = false; + + /** + * @generated from field: bool video_only = 3; + */ + videoOnly = false; + + /** + * @generated from field: bool await_start_signal = 12; + */ + awaitStartSignal = false; + + /** + * deprecated (use _output fields) + * + * @generated from oneof livekit.WebEgressRequest.output + */ + output: { + /** + * @generated from field: livekit.EncodedFileOutput file = 4 [deprecated = true]; + * @deprecated + */ + value: EncodedFileOutput; + case: "file"; + } | { + /** + * @generated from field: livekit.StreamOutput stream = 5 [deprecated = true]; + * @deprecated + */ + value: StreamOutput; + case: "stream"; + } | { + /** + * @generated from field: livekit.SegmentedFileOutput segments = 6 [deprecated = true]; + * @deprecated + */ + value: SegmentedFileOutput; + case: "segments"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from oneof livekit.WebEgressRequest.options + */ + options: { + /** + * @generated from field: livekit.EncodingOptionsPreset preset = 7; + */ + value: EncodingOptionsPreset; + case: "preset"; + } | { + /** + * @generated from field: livekit.EncodingOptions advanced = 8; + */ + value: EncodingOptions; + case: "advanced"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.EncodedFileOutput file_outputs = 9; + */ + fileOutputs: EncodedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.StreamOutput stream_outputs = 10; + */ + streamOutputs: StreamOutput[] = []; + + /** + * @generated from field: repeated livekit.SegmentedFileOutput segment_outputs = 11; + */ + segmentOutputs: SegmentedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.ImageOutput image_outputs = 13; + */ + imageOutputs: ImageOutput[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.WebEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "audio_only", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "video_only", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 12, name: "await_start_signal", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "file", kind: "message", T: EncodedFileOutput, oneof: "output" }, + { no: 5, name: "stream", kind: "message", T: StreamOutput, oneof: "output" }, + { no: 6, name: "segments", kind: "message", T: SegmentedFileOutput, oneof: "output" }, + { no: 7, name: "preset", kind: "enum", T: proto3.getEnumType(EncodingOptionsPreset), oneof: "options" }, + { no: 8, name: "advanced", kind: "message", T: EncodingOptions, oneof: "options" }, + { no: 9, name: "file_outputs", kind: "message", T: EncodedFileOutput, repeated: true }, + { no: 10, name: "stream_outputs", kind: "message", T: StreamOutput, repeated: true }, + { no: 11, name: "segment_outputs", kind: "message", T: SegmentedFileOutput, repeated: true }, + { no: 13, name: "image_outputs", kind: "message", T: ImageOutput, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): WebEgressRequest { + return new WebEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): WebEgressRequest { + return new WebEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): WebEgressRequest { + return new WebEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: WebEgressRequest | PlainMessage | undefined, b: WebEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(WebEgressRequest, a, b); + } +} + +/** + * record audio and video from a single participant + * + * @generated from message livekit.ParticipantEgressRequest + */ +export class ParticipantEgressRequest extends Message { + /** + * required + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * required + * + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * (default false) + * + * @generated from field: bool screen_share = 3; + */ + screenShare = false; + + /** + * @generated from oneof livekit.ParticipantEgressRequest.options + */ + options: { + /** + * (default H264_720P_30) + * + * @generated from field: livekit.EncodingOptionsPreset preset = 4; + */ + value: EncodingOptionsPreset; + case: "preset"; + } | { + /** + * (optional) + * + * @generated from field: livekit.EncodingOptions advanced = 5; + */ + value: EncodingOptions; + case: "advanced"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.EncodedFileOutput file_outputs = 6; + */ + fileOutputs: EncodedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.StreamOutput stream_outputs = 7; + */ + streamOutputs: StreamOutput[] = []; + + /** + * @generated from field: repeated livekit.SegmentedFileOutput segment_outputs = 8; + */ + segmentOutputs: SegmentedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.ImageOutput image_outputs = 9; + */ + imageOutputs: ImageOutput[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ParticipantEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "screen_share", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "preset", kind: "enum", T: proto3.getEnumType(EncodingOptionsPreset), oneof: "options" }, + { no: 5, name: "advanced", kind: "message", T: EncodingOptions, oneof: "options" }, + { no: 6, name: "file_outputs", kind: "message", T: EncodedFileOutput, repeated: true }, + { no: 7, name: "stream_outputs", kind: "message", T: StreamOutput, repeated: true }, + { no: 8, name: "segment_outputs", kind: "message", T: SegmentedFileOutput, repeated: true }, + { no: 9, name: "image_outputs", kind: "message", T: ImageOutput, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ParticipantEgressRequest { + return new ParticipantEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ParticipantEgressRequest { + return new ParticipantEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ParticipantEgressRequest { + return new ParticipantEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: ParticipantEgressRequest | PlainMessage | undefined, b: ParticipantEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ParticipantEgressRequest, a, b); + } +} + +/** + * containerize up to one audio and one video track + * + * @generated from message livekit.TrackCompositeEgressRequest + */ +export class TrackCompositeEgressRequest extends Message { + /** + * required + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * (optional) + * + * @generated from field: string audio_track_id = 2; + */ + audioTrackId = ""; + + /** + * (optional) + * + * @generated from field: string video_track_id = 3; + */ + videoTrackId = ""; + + /** + * deprecated (use _output fields) + * + * @generated from oneof livekit.TrackCompositeEgressRequest.output + */ + output: { + /** + * @generated from field: livekit.EncodedFileOutput file = 4 [deprecated = true]; + * @deprecated + */ + value: EncodedFileOutput; + case: "file"; + } | { + /** + * @generated from field: livekit.StreamOutput stream = 5 [deprecated = true]; + * @deprecated + */ + value: StreamOutput; + case: "stream"; + } | { + /** + * @generated from field: livekit.SegmentedFileOutput segments = 8 [deprecated = true]; + * @deprecated + */ + value: SegmentedFileOutput; + case: "segments"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from oneof livekit.TrackCompositeEgressRequest.options + */ + options: { + /** + * (default H264_720P_30) + * + * @generated from field: livekit.EncodingOptionsPreset preset = 6; + */ + value: EncodingOptionsPreset; + case: "preset"; + } | { + /** + * (optional) + * + * @generated from field: livekit.EncodingOptions advanced = 7; + */ + value: EncodingOptions; + case: "advanced"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.EncodedFileOutput file_outputs = 11; + */ + fileOutputs: EncodedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.StreamOutput stream_outputs = 12; + */ + streamOutputs: StreamOutput[] = []; + + /** + * @generated from field: repeated livekit.SegmentedFileOutput segment_outputs = 13; + */ + segmentOutputs: SegmentedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.ImageOutput image_outputs = 14; + */ + imageOutputs: ImageOutput[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackCompositeEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "audio_track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "video_track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "file", kind: "message", T: EncodedFileOutput, oneof: "output" }, + { no: 5, name: "stream", kind: "message", T: StreamOutput, oneof: "output" }, + { no: 8, name: "segments", kind: "message", T: SegmentedFileOutput, oneof: "output" }, + { no: 6, name: "preset", kind: "enum", T: proto3.getEnumType(EncodingOptionsPreset), oneof: "options" }, + { no: 7, name: "advanced", kind: "message", T: EncodingOptions, oneof: "options" }, + { no: 11, name: "file_outputs", kind: "message", T: EncodedFileOutput, repeated: true }, + { no: 12, name: "stream_outputs", kind: "message", T: StreamOutput, repeated: true }, + { no: 13, name: "segment_outputs", kind: "message", T: SegmentedFileOutput, repeated: true }, + { no: 14, name: "image_outputs", kind: "message", T: ImageOutput, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackCompositeEgressRequest { + return new TrackCompositeEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackCompositeEgressRequest { + return new TrackCompositeEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackCompositeEgressRequest { + return new TrackCompositeEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: TrackCompositeEgressRequest | PlainMessage | undefined, b: TrackCompositeEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackCompositeEgressRequest, a, b); + } +} + +/** + * record tracks individually, without transcoding + * + * @generated from message livekit.TrackEgressRequest + */ +export class TrackEgressRequest extends Message { + /** + * required + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * required + * + * @generated from field: string track_id = 2; + */ + trackId = ""; + + /** + * required + * + * @generated from oneof livekit.TrackEgressRequest.output + */ + output: { + /** + * @generated from field: livekit.DirectFileOutput file = 3; + */ + value: DirectFileOutput; + case: "file"; + } | { + /** + * @generated from field: string websocket_url = 4; + */ + value: string; + case: "websocketUrl"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "file", kind: "message", T: DirectFileOutput, oneof: "output" }, + { no: 4, name: "websocket_url", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackEgressRequest { + return new TrackEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackEgressRequest { + return new TrackEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackEgressRequest { + return new TrackEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: TrackEgressRequest | PlainMessage | undefined, b: TrackEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackEgressRequest, a, b); + } +} + +/** + * @generated from message livekit.EncodedFileOutput + */ +export class EncodedFileOutput extends Message { + /** + * (optional) + * + * @generated from field: livekit.EncodedFileType file_type = 1; + */ + fileType = EncodedFileType.DEFAULT_FILETYPE; + + /** + * see egress docs for templating (default {room_name}-{time}) + * + * @generated from field: string filepath = 2; + */ + filepath = ""; + + /** + * disable upload of manifest file (default false) + * + * @generated from field: bool disable_manifest = 6; + */ + disableManifest = false; + + /** + * @generated from oneof livekit.EncodedFileOutput.output + */ + output: { + /** + * @generated from field: livekit.S3Upload s3 = 3; + */ + value: S3Upload; + case: "s3"; + } | { + /** + * @generated from field: livekit.GCPUpload gcp = 4; + */ + value: GCPUpload; + case: "gcp"; + } | { + /** + * @generated from field: livekit.AzureBlobUpload azure = 5; + */ + value: AzureBlobUpload; + case: "azure"; + } | { + /** + * @generated from field: livekit.AliOSSUpload aliOSS = 7; + */ + value: AliOSSUpload; + case: "aliOSS"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.EncodedFileOutput"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "file_type", kind: "enum", T: proto3.getEnumType(EncodedFileType) }, + { no: 2, name: "filepath", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "disable_manifest", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "s3", kind: "message", T: S3Upload, oneof: "output" }, + { no: 4, name: "gcp", kind: "message", T: GCPUpload, oneof: "output" }, + { no: 5, name: "azure", kind: "message", T: AzureBlobUpload, oneof: "output" }, + { no: 7, name: "aliOSS", kind: "message", T: AliOSSUpload, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EncodedFileOutput { + return new EncodedFileOutput().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EncodedFileOutput { + return new EncodedFileOutput().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EncodedFileOutput { + return new EncodedFileOutput().fromJsonString(jsonString, options); + } + + static equals(a: EncodedFileOutput | PlainMessage | undefined, b: EncodedFileOutput | PlainMessage | undefined): boolean { + return proto3.util.equals(EncodedFileOutput, a, b); + } +} + +/** + * Used to generate HLS segments or other kind of segmented output + * + * @generated from message livekit.SegmentedFileOutput + */ +export class SegmentedFileOutput extends Message { + /** + * (optional) + * + * @generated from field: livekit.SegmentedFileProtocol protocol = 1; + */ + protocol = SegmentedFileProtocol.DEFAULT_SEGMENTED_FILE_PROTOCOL; + + /** + * (optional) + * + * @generated from field: string filename_prefix = 2; + */ + filenamePrefix = ""; + + /** + * (optional) + * + * @generated from field: string playlist_name = 3; + */ + playlistName = ""; + + /** + * (optional, disabled if not provided). Path of a live playlist + * + * @generated from field: string live_playlist_name = 11; + */ + livePlaylistName = ""; + + /** + * in seconds (optional) + * + * @generated from field: uint32 segment_duration = 4; + */ + segmentDuration = 0; + + /** + * (optional, default INDEX) + * + * @generated from field: livekit.SegmentedFileSuffix filename_suffix = 10; + */ + filenameSuffix = SegmentedFileSuffix.INDEX; + + /** + * disable upload of manifest file (default false) + * + * @generated from field: bool disable_manifest = 8; + */ + disableManifest = false; + + /** + * required + * + * @generated from oneof livekit.SegmentedFileOutput.output + */ + output: { + /** + * @generated from field: livekit.S3Upload s3 = 5; + */ + value: S3Upload; + case: "s3"; + } | { + /** + * @generated from field: livekit.GCPUpload gcp = 6; + */ + value: GCPUpload; + case: "gcp"; + } | { + /** + * @generated from field: livekit.AzureBlobUpload azure = 7; + */ + value: AzureBlobUpload; + case: "azure"; + } | { + /** + * @generated from field: livekit.AliOSSUpload aliOSS = 9; + */ + value: AliOSSUpload; + case: "aliOSS"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SegmentedFileOutput"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "protocol", kind: "enum", T: proto3.getEnumType(SegmentedFileProtocol) }, + { no: 2, name: "filename_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "live_playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "segment_duration", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 10, name: "filename_suffix", kind: "enum", T: proto3.getEnumType(SegmentedFileSuffix) }, + { no: 8, name: "disable_manifest", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 5, name: "s3", kind: "message", T: S3Upload, oneof: "output" }, + { no: 6, name: "gcp", kind: "message", T: GCPUpload, oneof: "output" }, + { no: 7, name: "azure", kind: "message", T: AzureBlobUpload, oneof: "output" }, + { no: 9, name: "aliOSS", kind: "message", T: AliOSSUpload, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SegmentedFileOutput { + return new SegmentedFileOutput().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SegmentedFileOutput { + return new SegmentedFileOutput().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SegmentedFileOutput { + return new SegmentedFileOutput().fromJsonString(jsonString, options); + } + + static equals(a: SegmentedFileOutput | PlainMessage | undefined, b: SegmentedFileOutput | PlainMessage | undefined): boolean { + return proto3.util.equals(SegmentedFileOutput, a, b); + } +} + +/** + * @generated from message livekit.DirectFileOutput + */ +export class DirectFileOutput extends Message { + /** + * see egress docs for templating (default {track_id}-{time}) + * + * @generated from field: string filepath = 1; + */ + filepath = ""; + + /** + * disable upload of manifest file (default false) + * + * @generated from field: bool disable_manifest = 5; + */ + disableManifest = false; + + /** + * @generated from oneof livekit.DirectFileOutput.output + */ + output: { + /** + * @generated from field: livekit.S3Upload s3 = 2; + */ + value: S3Upload; + case: "s3"; + } | { + /** + * @generated from field: livekit.GCPUpload gcp = 3; + */ + value: GCPUpload; + case: "gcp"; + } | { + /** + * @generated from field: livekit.AzureBlobUpload azure = 4; + */ + value: AzureBlobUpload; + case: "azure"; + } | { + /** + * @generated from field: livekit.AliOSSUpload aliOSS = 6; + */ + value: AliOSSUpload; + case: "aliOSS"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DirectFileOutput"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "filepath", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "disable_manifest", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "s3", kind: "message", T: S3Upload, oneof: "output" }, + { no: 3, name: "gcp", kind: "message", T: GCPUpload, oneof: "output" }, + { no: 4, name: "azure", kind: "message", T: AzureBlobUpload, oneof: "output" }, + { no: 6, name: "aliOSS", kind: "message", T: AliOSSUpload, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DirectFileOutput { + return new DirectFileOutput().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DirectFileOutput { + return new DirectFileOutput().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DirectFileOutput { + return new DirectFileOutput().fromJsonString(jsonString, options); + } + + static equals(a: DirectFileOutput | PlainMessage | undefined, b: DirectFileOutput | PlainMessage | undefined): boolean { + return proto3.util.equals(DirectFileOutput, a, b); + } +} + +/** + * @generated from message livekit.ImageOutput + */ +export class ImageOutput extends Message { + /** + * in seconds (required) + * + * @generated from field: uint32 capture_interval = 1; + */ + captureInterval = 0; + + /** + * (optional, defaults to track width) + * + * @generated from field: int32 width = 2; + */ + width = 0; + + /** + * (optional, defaults to track height) + * + * @generated from field: int32 height = 3; + */ + height = 0; + + /** + * (optional) + * + * @generated from field: string filename_prefix = 4; + */ + filenamePrefix = ""; + + /** + * (optional, default INDEX) + * + * @generated from field: livekit.ImageFileSuffix filename_suffix = 5; + */ + filenameSuffix = ImageFileSuffix.IMAGE_SUFFIX_INDEX; + + /** + * (optional) + * + * @generated from field: livekit.ImageCodec image_codec = 6; + */ + imageCodec = ImageCodec.IC_DEFAULT; + + /** + * disable upload of manifest file (default false) + * + * @generated from field: bool disable_manifest = 7; + */ + disableManifest = false; + + /** + * required + * + * @generated from oneof livekit.ImageOutput.output + */ + output: { + /** + * @generated from field: livekit.S3Upload s3 = 8; + */ + value: S3Upload; + case: "s3"; + } | { + /** + * @generated from field: livekit.GCPUpload gcp = 9; + */ + value: GCPUpload; + case: "gcp"; + } | { + /** + * @generated from field: livekit.AzureBlobUpload azure = 10; + */ + value: AzureBlobUpload; + case: "azure"; + } | { + /** + * @generated from field: livekit.AliOSSUpload aliOSS = 11; + */ + value: AliOSSUpload; + case: "aliOSS"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ImageOutput"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "capture_interval", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "width", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 3, name: "height", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "filename_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "filename_suffix", kind: "enum", T: proto3.getEnumType(ImageFileSuffix) }, + { no: 6, name: "image_codec", kind: "enum", T: proto3.getEnumType(ImageCodec) }, + { no: 7, name: "disable_manifest", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 8, name: "s3", kind: "message", T: S3Upload, oneof: "output" }, + { no: 9, name: "gcp", kind: "message", T: GCPUpload, oneof: "output" }, + { no: 10, name: "azure", kind: "message", T: AzureBlobUpload, oneof: "output" }, + { no: 11, name: "aliOSS", kind: "message", T: AliOSSUpload, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ImageOutput { + return new ImageOutput().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ImageOutput { + return new ImageOutput().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ImageOutput { + return new ImageOutput().fromJsonString(jsonString, options); + } + + static equals(a: ImageOutput | PlainMessage | undefined, b: ImageOutput | PlainMessage | undefined): boolean { + return proto3.util.equals(ImageOutput, a, b); + } +} + +/** + * @generated from message livekit.S3Upload + */ +export class S3Upload extends Message { + /** + * @generated from field: string access_key = 1; + */ + accessKey = ""; + + /** + * @generated from field: string secret = 2; + */ + secret = ""; + + /** + * @generated from field: string session_token = 11; + */ + sessionToken = ""; + + /** + * @generated from field: string region = 3; + */ + region = ""; + + /** + * @generated from field: string endpoint = 4; + */ + endpoint = ""; + + /** + * @generated from field: string bucket = 5; + */ + bucket = ""; + + /** + * @generated from field: bool force_path_style = 6; + */ + forcePathStyle = false; + + /** + * @generated from field: map metadata = 7; + */ + metadata: { [key: string]: string } = {}; + + /** + * @generated from field: string tagging = 8; + */ + tagging = ""; + + /** + * Content-Disposition header + * + * @generated from field: string content_disposition = 9; + */ + contentDisposition = ""; + + /** + * @generated from field: livekit.ProxyConfig proxy = 10; + */ + proxy?: ProxyConfig; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.S3Upload"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "access_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "secret", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "session_token", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "endpoint", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "bucket", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "force_path_style", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 7, name: "metadata", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 8, name: "tagging", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "content_disposition", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "proxy", kind: "message", T: ProxyConfig }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): S3Upload { + return new S3Upload().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): S3Upload { + return new S3Upload().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): S3Upload { + return new S3Upload().fromJsonString(jsonString, options); + } + + static equals(a: S3Upload | PlainMessage | undefined, b: S3Upload | PlainMessage | undefined): boolean { + return proto3.util.equals(S3Upload, a, b); + } +} + +/** + * @generated from message livekit.GCPUpload + */ +export class GCPUpload extends Message { + /** + * service account credentials serialized in JSON "credentials.json" + * + * @generated from field: string credentials = 1; + */ + credentials = ""; + + /** + * @generated from field: string bucket = 2; + */ + bucket = ""; + + /** + * @generated from field: livekit.ProxyConfig proxy = 3; + */ + proxy?: ProxyConfig; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.GCPUpload"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "credentials", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "bucket", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "proxy", kind: "message", T: ProxyConfig }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GCPUpload { + return new GCPUpload().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GCPUpload { + return new GCPUpload().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GCPUpload { + return new GCPUpload().fromJsonString(jsonString, options); + } + + static equals(a: GCPUpload | PlainMessage | undefined, b: GCPUpload | PlainMessage | undefined): boolean { + return proto3.util.equals(GCPUpload, a, b); + } +} + +/** + * @generated from message livekit.AzureBlobUpload + */ +export class AzureBlobUpload extends Message { + /** + * @generated from field: string account_name = 1; + */ + accountName = ""; + + /** + * @generated from field: string account_key = 2; + */ + accountKey = ""; + + /** + * @generated from field: string container_name = 3; + */ + containerName = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AzureBlobUpload"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "account_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "account_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "container_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AzureBlobUpload { + return new AzureBlobUpload().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AzureBlobUpload { + return new AzureBlobUpload().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AzureBlobUpload { + return new AzureBlobUpload().fromJsonString(jsonString, options); + } + + static equals(a: AzureBlobUpload | PlainMessage | undefined, b: AzureBlobUpload | PlainMessage | undefined): boolean { + return proto3.util.equals(AzureBlobUpload, a, b); + } +} + +/** + * @generated from message livekit.AliOSSUpload + */ +export class AliOSSUpload extends Message { + /** + * @generated from field: string access_key = 1; + */ + accessKey = ""; + + /** + * @generated from field: string secret = 2; + */ + secret = ""; + + /** + * @generated from field: string region = 3; + */ + region = ""; + + /** + * @generated from field: string endpoint = 4; + */ + endpoint = ""; + + /** + * @generated from field: string bucket = 5; + */ + bucket = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AliOSSUpload"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "access_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "secret", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "endpoint", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "bucket", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AliOSSUpload { + return new AliOSSUpload().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AliOSSUpload { + return new AliOSSUpload().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AliOSSUpload { + return new AliOSSUpload().fromJsonString(jsonString, options); + } + + static equals(a: AliOSSUpload | PlainMessage | undefined, b: AliOSSUpload | PlainMessage | undefined): boolean { + return proto3.util.equals(AliOSSUpload, a, b); + } +} + +/** + * @generated from message livekit.ProxyConfig + */ +export class ProxyConfig extends Message { + /** + * @generated from field: string url = 1; + */ + url = ""; + + /** + * @generated from field: string username = 2; + */ + username = ""; + + /** + * @generated from field: string password = 3; + */ + password = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ProxyConfig"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ProxyConfig { + return new ProxyConfig().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ProxyConfig { + return new ProxyConfig().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ProxyConfig { + return new ProxyConfig().fromJsonString(jsonString, options); + } + + static equals(a: ProxyConfig | PlainMessage | undefined, b: ProxyConfig | PlainMessage | undefined): boolean { + return proto3.util.equals(ProxyConfig, a, b); + } +} + +/** + * @generated from message livekit.StreamOutput + */ +export class StreamOutput extends Message { + /** + * required + * + * @generated from field: livekit.StreamProtocol protocol = 1; + */ + protocol = StreamProtocol.DEFAULT_PROTOCOL; + + /** + * required + * + * @generated from field: repeated string urls = 2; + */ + urls: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StreamOutput"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "protocol", kind: "enum", T: proto3.getEnumType(StreamProtocol) }, + { no: 2, name: "urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamOutput { + return new StreamOutput().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamOutput { + return new StreamOutput().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamOutput { + return new StreamOutput().fromJsonString(jsonString, options); + } + + static equals(a: StreamOutput | PlainMessage | undefined, b: StreamOutput | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamOutput, a, b); + } +} + +/** + * @generated from message livekit.EncodingOptions + */ +export class EncodingOptions extends Message { + /** + * (default 1920) + * + * @generated from field: int32 width = 1; + */ + width = 0; + + /** + * (default 1080) + * + * @generated from field: int32 height = 2; + */ + height = 0; + + /** + * (default 24) + * + * @generated from field: int32 depth = 3; + */ + depth = 0; + + /** + * (default 30) + * + * @generated from field: int32 framerate = 4; + */ + framerate = 0; + + /** + * (default OPUS) + * + * @generated from field: livekit.AudioCodec audio_codec = 5; + */ + audioCodec = AudioCodec.DEFAULT_AC; + + /** + * (default 128) + * + * @generated from field: int32 audio_bitrate = 6; + */ + audioBitrate = 0; + + /** + * quality setting on audio encoder + * + * @generated from field: int32 audio_quality = 11; + */ + audioQuality = 0; + + /** + * (default 44100) + * + * @generated from field: int32 audio_frequency = 7; + */ + audioFrequency = 0; + + /** + * (default H264_MAIN) + * + * @generated from field: livekit.VideoCodec video_codec = 8; + */ + videoCodec = VideoCodec.DEFAULT_VC; + + /** + * (default 4500) + * + * @generated from field: int32 video_bitrate = 9; + */ + videoBitrate = 0; + + /** + * quality setting on video encoder + * + * @generated from field: int32 video_quality = 12; + */ + videoQuality = 0; + + /** + * in seconds (default 4s for streaming, segment duration for segmented output, encoder default for files) + * + * @generated from field: double key_frame_interval = 10; + */ + keyFrameInterval = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.EncodingOptions"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "width", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 2, name: "height", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 3, name: "depth", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "framerate", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 5, name: "audio_codec", kind: "enum", T: proto3.getEnumType(AudioCodec) }, + { no: 6, name: "audio_bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 11, name: "audio_quality", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 7, name: "audio_frequency", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 8, name: "video_codec", kind: "enum", T: proto3.getEnumType(VideoCodec) }, + { no: 9, name: "video_bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 12, name: "video_quality", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 10, name: "key_frame_interval", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EncodingOptions { + return new EncodingOptions().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EncodingOptions { + return new EncodingOptions().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EncodingOptions { + return new EncodingOptions().fromJsonString(jsonString, options); + } + + static equals(a: EncodingOptions | PlainMessage | undefined, b: EncodingOptions | PlainMessage | undefined): boolean { + return proto3.util.equals(EncodingOptions, a, b); + } +} + +/** + * @generated from message livekit.UpdateLayoutRequest + */ +export class UpdateLayoutRequest extends Message { + /** + * @generated from field: string egress_id = 1; + */ + egressId = ""; + + /** + * @generated from field: string layout = 2; + */ + layout = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateLayoutRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "layout", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateLayoutRequest { + return new UpdateLayoutRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateLayoutRequest { + return new UpdateLayoutRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateLayoutRequest { + return new UpdateLayoutRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateLayoutRequest | PlainMessage | undefined, b: UpdateLayoutRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateLayoutRequest, a, b); + } +} + +/** + * @generated from message livekit.UpdateStreamRequest + */ +export class UpdateStreamRequest extends Message { + /** + * @generated from field: string egress_id = 1; + */ + egressId = ""; + + /** + * @generated from field: repeated string add_output_urls = 2; + */ + addOutputUrls: string[] = []; + + /** + * @generated from field: repeated string remove_output_urls = 3; + */ + removeOutputUrls: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateStreamRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "add_output_urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 3, name: "remove_output_urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateStreamRequest { + return new UpdateStreamRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateStreamRequest { + return new UpdateStreamRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateStreamRequest { + return new UpdateStreamRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateStreamRequest | PlainMessage | undefined, b: UpdateStreamRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateStreamRequest, a, b); + } +} + +/** + * @generated from message livekit.ListEgressRequest + */ +export class ListEgressRequest extends Message { + /** + * (optional, filter by room name) + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * (optional, filter by egress ID) + * + * @generated from field: string egress_id = 2; + */ + egressId = ""; + + /** + * (optional, list active egress only) + * + * @generated from field: bool active = 3; + */ + active = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "active", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListEgressRequest { + return new ListEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListEgressRequest { + return new ListEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListEgressRequest { + return new ListEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListEgressRequest | PlainMessage | undefined, b: ListEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListEgressRequest, a, b); + } +} + +/** + * @generated from message livekit.ListEgressResponse + */ +export class ListEgressResponse extends Message { + /** + * @generated from field: repeated livekit.EgressInfo items = 1; + */ + items: EgressInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListEgressResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: EgressInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListEgressResponse { + return new ListEgressResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListEgressResponse { + return new ListEgressResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListEgressResponse { + return new ListEgressResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListEgressResponse | PlainMessage | undefined, b: ListEgressResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListEgressResponse, a, b); + } +} + +/** + * @generated from message livekit.StopEgressRequest + */ +export class StopEgressRequest extends Message { + /** + * @generated from field: string egress_id = 1; + */ + egressId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StopEgressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StopEgressRequest { + return new StopEgressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StopEgressRequest { + return new StopEgressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StopEgressRequest { + return new StopEgressRequest().fromJsonString(jsonString, options); + } + + static equals(a: StopEgressRequest | PlainMessage | undefined, b: StopEgressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(StopEgressRequest, a, b); + } +} + +/** + * @generated from message livekit.EgressInfo + */ +export class EgressInfo extends Message { + /** + * @generated from field: string egress_id = 1; + */ + egressId = ""; + + /** + * @generated from field: string room_id = 2; + */ + roomId = ""; + + /** + * @generated from field: string room_name = 13; + */ + roomName = ""; + + /** + * @generated from field: livekit.EgressStatus status = 3; + */ + status = EgressStatus.EGRESS_STARTING; + + /** + * @generated from field: int64 started_at = 10; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 11; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: int64 updated_at = 18; + */ + updatedAt = protoInt64.zero; + + /** + * @generated from field: string details = 21; + */ + details = ""; + + /** + * @generated from field: string error = 9; + */ + error = ""; + + /** + * @generated from field: int32 error_code = 22; + */ + errorCode = 0; + + /** + * @generated from oneof livekit.EgressInfo.request + */ + request: { + /** + * @generated from field: livekit.RoomCompositeEgressRequest room_composite = 4; + */ + value: RoomCompositeEgressRequest; + case: "roomComposite"; + } | { + /** + * @generated from field: livekit.WebEgressRequest web = 14; + */ + value: WebEgressRequest; + case: "web"; + } | { + /** + * @generated from field: livekit.ParticipantEgressRequest participant = 19; + */ + value: ParticipantEgressRequest; + case: "participant"; + } | { + /** + * @generated from field: livekit.TrackCompositeEgressRequest track_composite = 5; + */ + value: TrackCompositeEgressRequest; + case: "trackComposite"; + } | { + /** + * @generated from field: livekit.TrackEgressRequest track = 6; + */ + value: TrackEgressRequest; + case: "track"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * deprecated (use _result fields) + * + * @generated from oneof livekit.EgressInfo.result + */ + result: { + /** + * @generated from field: livekit.StreamInfoList stream = 7 [deprecated = true]; + * @deprecated + */ + value: StreamInfoList; + case: "stream"; + } | { + /** + * @generated from field: livekit.FileInfo file = 8 [deprecated = true]; + * @deprecated + */ + value: FileInfo; + case: "file"; + } | { + /** + * @generated from field: livekit.SegmentsInfo segments = 12 [deprecated = true]; + * @deprecated + */ + value: SegmentsInfo; + case: "segments"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.StreamInfo stream_results = 15; + */ + streamResults: StreamInfo[] = []; + + /** + * @generated from field: repeated livekit.FileInfo file_results = 16; + */ + fileResults: FileInfo[] = []; + + /** + * @generated from field: repeated livekit.SegmentsInfo segment_results = 17; + */ + segmentResults: SegmentsInfo[] = []; + + /** + * @generated from field: repeated livekit.ImagesInfo image_results = 20; + */ + imageResults: ImagesInfo[] = []; + + /** + * @generated from field: string manifest_location = 23; + */ + manifestLocation = ""; + + /** + * next ID: 26 + * + * @generated from field: bool backup_storage_used = 25; + */ + backupStorageUsed = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.EgressInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 13, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "status", kind: "enum", T: proto3.getEnumType(EgressStatus) }, + { no: 10, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 11, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 18, name: "updated_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 21, name: "details", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 22, name: "error_code", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "room_composite", kind: "message", T: RoomCompositeEgressRequest, oneof: "request" }, + { no: 14, name: "web", kind: "message", T: WebEgressRequest, oneof: "request" }, + { no: 19, name: "participant", kind: "message", T: ParticipantEgressRequest, oneof: "request" }, + { no: 5, name: "track_composite", kind: "message", T: TrackCompositeEgressRequest, oneof: "request" }, + { no: 6, name: "track", kind: "message", T: TrackEgressRequest, oneof: "request" }, + { no: 7, name: "stream", kind: "message", T: StreamInfoList, oneof: "result" }, + { no: 8, name: "file", kind: "message", T: FileInfo, oneof: "result" }, + { no: 12, name: "segments", kind: "message", T: SegmentsInfo, oneof: "result" }, + { no: 15, name: "stream_results", kind: "message", T: StreamInfo, repeated: true }, + { no: 16, name: "file_results", kind: "message", T: FileInfo, repeated: true }, + { no: 17, name: "segment_results", kind: "message", T: SegmentsInfo, repeated: true }, + { no: 20, name: "image_results", kind: "message", T: ImagesInfo, repeated: true }, + { no: 23, name: "manifest_location", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 25, name: "backup_storage_used", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EgressInfo { + return new EgressInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EgressInfo { + return new EgressInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EgressInfo { + return new EgressInfo().fromJsonString(jsonString, options); + } + + static equals(a: EgressInfo | PlainMessage | undefined, b: EgressInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(EgressInfo, a, b); + } +} + +/** + * @generated from message livekit.StreamInfoList + * @deprecated + */ +export class StreamInfoList extends Message { + /** + * @generated from field: repeated livekit.StreamInfo info = 1; + */ + info: StreamInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StreamInfoList"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "info", kind: "message", T: StreamInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamInfoList { + return new StreamInfoList().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamInfoList { + return new StreamInfoList().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamInfoList { + return new StreamInfoList().fromJsonString(jsonString, options); + } + + static equals(a: StreamInfoList | PlainMessage | undefined, b: StreamInfoList | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamInfoList, a, b); + } +} + +/** + * @generated from message livekit.StreamInfo + */ +export class StreamInfo extends Message { + /** + * @generated from field: string url = 1; + */ + url = ""; + + /** + * @generated from field: int64 started_at = 2; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 3; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: int64 duration = 4; + */ + duration = protoInt64.zero; + + /** + * @generated from field: livekit.StreamInfo.Status status = 5; + */ + status = StreamInfo_Status.ACTIVE; + + /** + * @generated from field: string error = 6; + */ + error = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StreamInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 4, name: "duration", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 5, name: "status", kind: "enum", T: proto3.getEnumType(StreamInfo_Status) }, + { no: 6, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamInfo { + return new StreamInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamInfo { + return new StreamInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamInfo { + return new StreamInfo().fromJsonString(jsonString, options); + } + + static equals(a: StreamInfo | PlainMessage | undefined, b: StreamInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamInfo, a, b); + } +} + +/** + * @generated from enum livekit.StreamInfo.Status + */ +export enum StreamInfo_Status { + /** + * @generated from enum value: ACTIVE = 0; + */ + ACTIVE = 0, + + /** + * @generated from enum value: FINISHED = 1; + */ + FINISHED = 1, + + /** + * @generated from enum value: FAILED = 2; + */ + FAILED = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(StreamInfo_Status) +proto3.util.setEnumType(StreamInfo_Status, "livekit.StreamInfo.Status", [ + { no: 0, name: "ACTIVE" }, + { no: 1, name: "FINISHED" }, + { no: 2, name: "FAILED" }, +]); + +/** + * @generated from message livekit.FileInfo + */ +export class FileInfo extends Message { + /** + * @generated from field: string filename = 1; + */ + filename = ""; + + /** + * @generated from field: int64 started_at = 2; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 3; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: int64 duration = 6; + */ + duration = protoInt64.zero; + + /** + * @generated from field: int64 size = 4; + */ + size = protoInt64.zero; + + /** + * @generated from field: string location = 5; + */ + location = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.FileInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "filename", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 6, name: "duration", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 4, name: "size", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 5, name: "location", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): FileInfo { + return new FileInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): FileInfo { + return new FileInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): FileInfo { + return new FileInfo().fromJsonString(jsonString, options); + } + + static equals(a: FileInfo | PlainMessage | undefined, b: FileInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(FileInfo, a, b); + } +} + +/** + * @generated from message livekit.SegmentsInfo + */ +export class SegmentsInfo extends Message { + /** + * @generated from field: string playlist_name = 1; + */ + playlistName = ""; + + /** + * @generated from field: string live_playlist_name = 8; + */ + livePlaylistName = ""; + + /** + * @generated from field: int64 duration = 2; + */ + duration = protoInt64.zero; + + /** + * @generated from field: int64 size = 3; + */ + size = protoInt64.zero; + + /** + * @generated from field: string playlist_location = 4; + */ + playlistLocation = ""; + + /** + * @generated from field: string live_playlist_location = 9; + */ + livePlaylistLocation = ""; + + /** + * @generated from field: int64 segment_count = 5; + */ + segmentCount = protoInt64.zero; + + /** + * @generated from field: int64 started_at = 6; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 7; + */ + endedAt = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SegmentsInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "live_playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "duration", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "size", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 4, name: "playlist_location", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "live_playlist_location", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "segment_count", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 6, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 7, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SegmentsInfo { + return new SegmentsInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SegmentsInfo { + return new SegmentsInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SegmentsInfo { + return new SegmentsInfo().fromJsonString(jsonString, options); + } + + static equals(a: SegmentsInfo | PlainMessage | undefined, b: SegmentsInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SegmentsInfo, a, b); + } +} + +/** + * @generated from message livekit.ImagesInfo + */ +export class ImagesInfo extends Message { + /** + * @generated from field: string filename_prefix = 4; + */ + filenamePrefix = ""; + + /** + * @generated from field: int64 image_count = 1; + */ + imageCount = protoInt64.zero; + + /** + * @generated from field: int64 started_at = 2; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 3; + */ + endedAt = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ImagesInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 4, name: "filename_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 1, name: "image_count", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ImagesInfo { + return new ImagesInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ImagesInfo { + return new ImagesInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ImagesInfo { + return new ImagesInfo().fromJsonString(jsonString, options); + } + + static equals(a: ImagesInfo | PlainMessage | undefined, b: ImagesInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(ImagesInfo, a, b); + } +} + +/** + * @generated from message livekit.AutoParticipantEgress + */ +export class AutoParticipantEgress extends Message { + /** + * @generated from oneof livekit.AutoParticipantEgress.options + */ + options: { + /** + * (default H264_720P_30) + * + * @generated from field: livekit.EncodingOptionsPreset preset = 1; + */ + value: EncodingOptionsPreset; + case: "preset"; + } | { + /** + * (optional) + * + * @generated from field: livekit.EncodingOptions advanced = 2; + */ + value: EncodingOptions; + case: "advanced"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.EncodedFileOutput file_outputs = 3; + */ + fileOutputs: EncodedFileOutput[] = []; + + /** + * @generated from field: repeated livekit.SegmentedFileOutput segment_outputs = 4; + */ + segmentOutputs: SegmentedFileOutput[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AutoParticipantEgress"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "preset", kind: "enum", T: proto3.getEnumType(EncodingOptionsPreset), oneof: "options" }, + { no: 2, name: "advanced", kind: "message", T: EncodingOptions, oneof: "options" }, + { no: 3, name: "file_outputs", kind: "message", T: EncodedFileOutput, repeated: true }, + { no: 4, name: "segment_outputs", kind: "message", T: SegmentedFileOutput, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AutoParticipantEgress { + return new AutoParticipantEgress().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AutoParticipantEgress { + return new AutoParticipantEgress().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AutoParticipantEgress { + return new AutoParticipantEgress().fromJsonString(jsonString, options); + } + + static equals(a: AutoParticipantEgress | PlainMessage | undefined, b: AutoParticipantEgress | PlainMessage | undefined): boolean { + return proto3.util.equals(AutoParticipantEgress, a, b); + } +} + +/** + * @generated from message livekit.AutoTrackEgress + */ +export class AutoTrackEgress extends Message { + /** + * see docs for templating (default {track_id}-{time}) + * + * @generated from field: string filepath = 1; + */ + filepath = ""; + + /** + * disables upload of json manifest file (default false) + * + * @generated from field: bool disable_manifest = 5; + */ + disableManifest = false; + + /** + * @generated from oneof livekit.AutoTrackEgress.output + */ + output: { + /** + * @generated from field: livekit.S3Upload s3 = 2; + */ + value: S3Upload; + case: "s3"; + } | { + /** + * @generated from field: livekit.GCPUpload gcp = 3; + */ + value: GCPUpload; + case: "gcp"; + } | { + /** + * @generated from field: livekit.AzureBlobUpload azure = 4; + */ + value: AzureBlobUpload; + case: "azure"; + } | { + /** + * @generated from field: livekit.AliOSSUpload aliOSS = 6; + */ + value: AliOSSUpload; + case: "aliOSS"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AutoTrackEgress"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "filepath", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "disable_manifest", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "s3", kind: "message", T: S3Upload, oneof: "output" }, + { no: 3, name: "gcp", kind: "message", T: GCPUpload, oneof: "output" }, + { no: 4, name: "azure", kind: "message", T: AzureBlobUpload, oneof: "output" }, + { no: 6, name: "aliOSS", kind: "message", T: AliOSSUpload, oneof: "output" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AutoTrackEgress { + return new AutoTrackEgress().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AutoTrackEgress { + return new AutoTrackEgress().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AutoTrackEgress { + return new AutoTrackEgress().fromJsonString(jsonString, options); + } + + static equals(a: AutoTrackEgress | PlainMessage | undefined, b: AutoTrackEgress | PlainMessage | undefined): boolean { + return proto3.util.equals(AutoTrackEgress, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_ingress_pb.ts b/packages/javascript/src/gen/livekit_ingress_pb.ts new file mode 100644 index 00000000..04d1ac0e --- /dev/null +++ b/packages/javascript/src/gen/livekit_ingress_pb.ts @@ -0,0 +1,1105 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_ingress.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { AudioCodec, TrackInfo, TrackSource, VideoCodec, VideoLayer } from "./livekit_models_pb.js"; + +/** + * @generated from enum livekit.IngressInput + */ +export enum IngressInput { + /** + * @generated from enum value: RTMP_INPUT = 0; + */ + RTMP_INPUT = 0, + + /** + * @generated from enum value: WHIP_INPUT = 1; + */ + WHIP_INPUT = 1, + + /** + * Pull from the provided URL. Only HTTP url are supported, serving either a single media file or a HLS stream + * + * @generated from enum value: URL_INPUT = 2; + */ + URL_INPUT = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(IngressInput) +proto3.util.setEnumType(IngressInput, "livekit.IngressInput", [ + { no: 0, name: "RTMP_INPUT" }, + { no: 1, name: "WHIP_INPUT" }, + { no: 2, name: "URL_INPUT" }, +]); + +/** + * @generated from enum livekit.IngressAudioEncodingPreset + */ +export enum IngressAudioEncodingPreset { + /** + * OPUS, 2 channels, 96kbps + * + * @generated from enum value: OPUS_STEREO_96KBPS = 0; + */ + OPUS_STEREO_96KBPS = 0, + + /** + * OPUS, 1 channel, 64kbps + * + * @generated from enum value: OPUS_MONO_64KBS = 1; + */ + OPUS_MONO_64KBS = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(IngressAudioEncodingPreset) +proto3.util.setEnumType(IngressAudioEncodingPreset, "livekit.IngressAudioEncodingPreset", [ + { no: 0, name: "OPUS_STEREO_96KBPS" }, + { no: 1, name: "OPUS_MONO_64KBS" }, +]); + +/** + * @generated from enum livekit.IngressVideoEncodingPreset + */ +export enum IngressVideoEncodingPreset { + /** + * 1280x720, 30fps, 1900kbps main layer, 3 layers total + * + * @generated from enum value: H264_720P_30FPS_3_LAYERS = 0; + */ + H264_720P_30FPS_3_LAYERS = 0, + + /** + * 1980x1080, 30fps, 3500kbps main layer, 3 layers total + * + * @generated from enum value: H264_1080P_30FPS_3_LAYERS = 1; + */ + H264_1080P_30FPS_3_LAYERS = 1, + + /** + * 960x540, 25fps, 1000kbps main layer, 2 layers total + * + * @generated from enum value: H264_540P_25FPS_2_LAYERS = 2; + */ + H264_540P_25FPS_2_LAYERS = 2, + + /** + * 1280x720, 30fps, 1900kbps, no simulcast + * + * @generated from enum value: H264_720P_30FPS_1_LAYER = 3; + */ + H264_720P_30FPS_1_LAYER = 3, + + /** + * 1980x1080, 30fps, 3500kbps, no simulcast + * + * @generated from enum value: H264_1080P_30FPS_1_LAYER = 4; + */ + H264_1080P_30FPS_1_LAYER = 4, + + /** + * 1280x720, 30fps, 2500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content + * + * @generated from enum value: H264_720P_30FPS_3_LAYERS_HIGH_MOTION = 5; + */ + H264_720P_30FPS_3_LAYERS_HIGH_MOTION = 5, + + /** + * 1980x1080, 30fps, 4500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content + * + * @generated from enum value: H264_1080P_30FPS_3_LAYERS_HIGH_MOTION = 6; + */ + H264_1080P_30FPS_3_LAYERS_HIGH_MOTION = 6, + + /** + * 960x540, 25fps, 1300kbps main layer, 2 layers total, higher bitrate for high motion, harder to encode content + * + * @generated from enum value: H264_540P_25FPS_2_LAYERS_HIGH_MOTION = 7; + */ + H264_540P_25FPS_2_LAYERS_HIGH_MOTION = 7, + + /** + * 1280x720, 30fps, 2500kbps, no simulcast, higher bitrate for high motion, harder to encode content + * + * @generated from enum value: H264_720P_30FPS_1_LAYER_HIGH_MOTION = 8; + */ + H264_720P_30FPS_1_LAYER_HIGH_MOTION = 8, + + /** + * 1980x1080, 30fps, 4500kbps, no simulcast, higher bitrate for high motion, harder to encode content + * + * @generated from enum value: H264_1080P_30FPS_1_LAYER_HIGH_MOTION = 9; + */ + H264_1080P_30FPS_1_LAYER_HIGH_MOTION = 9, +} +// Retrieve enum metadata with: proto3.getEnumType(IngressVideoEncodingPreset) +proto3.util.setEnumType(IngressVideoEncodingPreset, "livekit.IngressVideoEncodingPreset", [ + { no: 0, name: "H264_720P_30FPS_3_LAYERS" }, + { no: 1, name: "H264_1080P_30FPS_3_LAYERS" }, + { no: 2, name: "H264_540P_25FPS_2_LAYERS" }, + { no: 3, name: "H264_720P_30FPS_1_LAYER" }, + { no: 4, name: "H264_1080P_30FPS_1_LAYER" }, + { no: 5, name: "H264_720P_30FPS_3_LAYERS_HIGH_MOTION" }, + { no: 6, name: "H264_1080P_30FPS_3_LAYERS_HIGH_MOTION" }, + { no: 7, name: "H264_540P_25FPS_2_LAYERS_HIGH_MOTION" }, + { no: 8, name: "H264_720P_30FPS_1_LAYER_HIGH_MOTION" }, + { no: 9, name: "H264_1080P_30FPS_1_LAYER_HIGH_MOTION" }, +]); + +/** + * @generated from message livekit.CreateIngressRequest + */ +export class CreateIngressRequest extends Message { + /** + * @generated from field: livekit.IngressInput input_type = 1; + */ + inputType = IngressInput.RTMP_INPUT; + + /** + * Where to pull media from, only for URL input type + * + * @generated from field: string url = 9; + */ + url = ""; + + /** + * User provided identifier for the ingress + * + * @generated from field: string name = 2; + */ + name = ""; + + /** + * room to publish to + * + * @generated from field: string room_name = 3; + */ + roomName = ""; + + /** + * publish as participant + * + * @generated from field: string participant_identity = 4; + */ + participantIdentity = ""; + + /** + * name of publishing participant (used for display only) + * + * @generated from field: string participant_name = 5; + */ + participantName = ""; + + /** + * metadata associated with the publishing participant + * + * @generated from field: string participant_metadata = 10; + */ + participantMetadata = ""; + + /** + * [depreacted ] whether to pass through the incoming media without transcoding, only compatible with some input types. Use `enable_transcoding` instead. + * + * @generated from field: bool bypass_transcoding = 8 [deprecated = true]; + * @deprecated + */ + bypassTranscoding = false; + + /** + * Whether to transcode the ingested media. Only WHIP supports disabling transcoding currently. WHIP will default to transcoding disabled. Replaces `bypass_transcoding. + * + * @generated from field: optional bool enable_transcoding = 11; + */ + enableTranscoding?: boolean; + + /** + * @generated from field: livekit.IngressAudioOptions audio = 6; + */ + audio?: IngressAudioOptions; + + /** + * @generated from field: livekit.IngressVideoOptions video = 7; + */ + video?: IngressVideoOptions; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateIngressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "input_type", kind: "enum", T: proto3.getEnumType(IngressInput) }, + { no: 9, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "participant_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "participant_metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "bypass_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 11, name: "enable_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 6, name: "audio", kind: "message", T: IngressAudioOptions }, + { no: 7, name: "video", kind: "message", T: IngressVideoOptions }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateIngressRequest { + return new CreateIngressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateIngressRequest { + return new CreateIngressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateIngressRequest { + return new CreateIngressRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateIngressRequest | PlainMessage | undefined, b: CreateIngressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateIngressRequest, a, b); + } +} + +/** + * @generated from message livekit.IngressAudioOptions + */ +export class IngressAudioOptions extends Message { + /** + * @generated from field: string name = 1; + */ + name = ""; + + /** + * @generated from field: livekit.TrackSource source = 2; + */ + source = TrackSource.UNKNOWN; + + /** + * @generated from oneof livekit.IngressAudioOptions.encoding_options + */ + encodingOptions: { + /** + * @generated from field: livekit.IngressAudioEncodingPreset preset = 3; + */ + value: IngressAudioEncodingPreset; + case: "preset"; + } | { + /** + * @generated from field: livekit.IngressAudioEncodingOptions options = 4; + */ + value: IngressAudioEncodingOptions; + case: "options"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressAudioOptions"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "source", kind: "enum", T: proto3.getEnumType(TrackSource) }, + { no: 3, name: "preset", kind: "enum", T: proto3.getEnumType(IngressAudioEncodingPreset), oneof: "encoding_options" }, + { no: 4, name: "options", kind: "message", T: IngressAudioEncodingOptions, oneof: "encoding_options" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressAudioOptions { + return new IngressAudioOptions().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressAudioOptions { + return new IngressAudioOptions().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressAudioOptions { + return new IngressAudioOptions().fromJsonString(jsonString, options); + } + + static equals(a: IngressAudioOptions | PlainMessage | undefined, b: IngressAudioOptions | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressAudioOptions, a, b); + } +} + +/** + * @generated from message livekit.IngressVideoOptions + */ +export class IngressVideoOptions extends Message { + /** + * @generated from field: string name = 1; + */ + name = ""; + + /** + * @generated from field: livekit.TrackSource source = 2; + */ + source = TrackSource.UNKNOWN; + + /** + * @generated from oneof livekit.IngressVideoOptions.encoding_options + */ + encodingOptions: { + /** + * @generated from field: livekit.IngressVideoEncodingPreset preset = 3; + */ + value: IngressVideoEncodingPreset; + case: "preset"; + } | { + /** + * @generated from field: livekit.IngressVideoEncodingOptions options = 4; + */ + value: IngressVideoEncodingOptions; + case: "options"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressVideoOptions"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "source", kind: "enum", T: proto3.getEnumType(TrackSource) }, + { no: 3, name: "preset", kind: "enum", T: proto3.getEnumType(IngressVideoEncodingPreset), oneof: "encoding_options" }, + { no: 4, name: "options", kind: "message", T: IngressVideoEncodingOptions, oneof: "encoding_options" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressVideoOptions { + return new IngressVideoOptions().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressVideoOptions { + return new IngressVideoOptions().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressVideoOptions { + return new IngressVideoOptions().fromJsonString(jsonString, options); + } + + static equals(a: IngressVideoOptions | PlainMessage | undefined, b: IngressVideoOptions | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressVideoOptions, a, b); + } +} + +/** + * @generated from message livekit.IngressAudioEncodingOptions + */ +export class IngressAudioEncodingOptions extends Message { + /** + * desired audio codec to publish to room + * + * @generated from field: livekit.AudioCodec audio_codec = 1; + */ + audioCodec = AudioCodec.DEFAULT_AC; + + /** + * @generated from field: uint32 bitrate = 2; + */ + bitrate = 0; + + /** + * @generated from field: bool disable_dtx = 3; + */ + disableDtx = false; + + /** + * @generated from field: uint32 channels = 4; + */ + channels = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressAudioEncodingOptions"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "audio_codec", kind: "enum", T: proto3.getEnumType(AudioCodec) }, + { no: 2, name: "bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "disable_dtx", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "channels", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressAudioEncodingOptions { + return new IngressAudioEncodingOptions().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressAudioEncodingOptions { + return new IngressAudioEncodingOptions().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressAudioEncodingOptions { + return new IngressAudioEncodingOptions().fromJsonString(jsonString, options); + } + + static equals(a: IngressAudioEncodingOptions | PlainMessage | undefined, b: IngressAudioEncodingOptions | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressAudioEncodingOptions, a, b); + } +} + +/** + * @generated from message livekit.IngressVideoEncodingOptions + */ +export class IngressVideoEncodingOptions extends Message { + /** + * desired codec to publish to room + * + * @generated from field: livekit.VideoCodec video_codec = 1; + */ + videoCodec = VideoCodec.DEFAULT_VC; + + /** + * @generated from field: double frame_rate = 2; + */ + frameRate = 0; + + /** + * simulcast layers to publish, when empty, should usually be set to layers at 1/2 and 1/4 of the dimensions + * + * @generated from field: repeated livekit.VideoLayer layers = 3; + */ + layers: VideoLayer[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressVideoEncodingOptions"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "video_codec", kind: "enum", T: proto3.getEnumType(VideoCodec) }, + { no: 2, name: "frame_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 3, name: "layers", kind: "message", T: VideoLayer, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressVideoEncodingOptions { + return new IngressVideoEncodingOptions().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressVideoEncodingOptions { + return new IngressVideoEncodingOptions().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressVideoEncodingOptions { + return new IngressVideoEncodingOptions().fromJsonString(jsonString, options); + } + + static equals(a: IngressVideoEncodingOptions | PlainMessage | undefined, b: IngressVideoEncodingOptions | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressVideoEncodingOptions, a, b); + } +} + +/** + * @generated from message livekit.IngressInfo + */ +export class IngressInfo extends Message { + /** + * @generated from field: string ingress_id = 1; + */ + ingressId = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * @generated from field: string stream_key = 3; + */ + streamKey = ""; + + /** + * URL to point the encoder to for push (RTMP, WHIP), or location to pull media from for pull (URL) + * + * @generated from field: string url = 4; + */ + url = ""; + + /** + * for RTMP input, it'll be a rtmp:// URL + * for FILE input, it'll be a http:// URL + * for SRT input, it'll be a srt:// URL + * + * @generated from field: livekit.IngressInput input_type = 5; + */ + inputType = IngressInput.RTMP_INPUT; + + /** + * @generated from field: bool bypass_transcoding = 13 [deprecated = true]; + * @deprecated + */ + bypassTranscoding = false; + + /** + * @generated from field: optional bool enable_transcoding = 15; + */ + enableTranscoding?: boolean; + + /** + * @generated from field: livekit.IngressAudioOptions audio = 6; + */ + audio?: IngressAudioOptions; + + /** + * @generated from field: livekit.IngressVideoOptions video = 7; + */ + video?: IngressVideoOptions; + + /** + * @generated from field: string room_name = 8; + */ + roomName = ""; + + /** + * @generated from field: string participant_identity = 9; + */ + participantIdentity = ""; + + /** + * @generated from field: string participant_name = 10; + */ + participantName = ""; + + /** + * @generated from field: string participant_metadata = 14; + */ + participantMetadata = ""; + + /** + * @generated from field: bool reusable = 11; + */ + reusable = false; + + /** + * Description of error/stream non compliance and debug info for publisher otherwise (received bitrate, resolution, bandwidth) + * + * @generated from field: livekit.IngressState state = 12; + */ + state?: IngressState; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "stream_key", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "input_type", kind: "enum", T: proto3.getEnumType(IngressInput) }, + { no: 13, name: "bypass_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 15, name: "enable_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 6, name: "audio", kind: "message", T: IngressAudioOptions }, + { no: 7, name: "video", kind: "message", T: IngressVideoOptions }, + { no: 8, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "participant_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 14, name: "participant_metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "reusable", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 12, name: "state", kind: "message", T: IngressState }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressInfo { + return new IngressInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressInfo { + return new IngressInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressInfo { + return new IngressInfo().fromJsonString(jsonString, options); + } + + static equals(a: IngressInfo | PlainMessage | undefined, b: IngressInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressInfo, a, b); + } +} + +/** + * @generated from message livekit.IngressState + */ +export class IngressState extends Message { + /** + * @generated from field: livekit.IngressState.Status status = 1; + */ + status = IngressState_Status.ENDPOINT_INACTIVE; + + /** + * Error/non compliance description if any + * + * @generated from field: string error = 2; + */ + error = ""; + + /** + * @generated from field: livekit.InputVideoState video = 3; + */ + video?: InputVideoState; + + /** + * @generated from field: livekit.InputAudioState audio = 4; + */ + audio?: InputAudioState; + + /** + * ID of the current/previous room published to + * + * @generated from field: string room_id = 5; + */ + roomId = ""; + + /** + * @generated from field: int64 started_at = 7; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 8; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: int64 updated_at = 10; + */ + updatedAt = protoInt64.zero; + + /** + * @generated from field: string resource_id = 9; + */ + resourceId = ""; + + /** + * @generated from field: repeated livekit.TrackInfo tracks = 6; + */ + tracks: TrackInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.IngressState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(IngressState_Status) }, + { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "video", kind: "message", T: InputVideoState }, + { no: 4, name: "audio", kind: "message", T: InputAudioState }, + { no: 5, name: "room_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 8, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 10, name: "updated_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 9, name: "resource_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "tracks", kind: "message", T: TrackInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): IngressState { + return new IngressState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): IngressState { + return new IngressState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): IngressState { + return new IngressState().fromJsonString(jsonString, options); + } + + static equals(a: IngressState | PlainMessage | undefined, b: IngressState | PlainMessage | undefined): boolean { + return proto3.util.equals(IngressState, a, b); + } +} + +/** + * @generated from enum livekit.IngressState.Status + */ +export enum IngressState_Status { + /** + * @generated from enum value: ENDPOINT_INACTIVE = 0; + */ + ENDPOINT_INACTIVE = 0, + + /** + * @generated from enum value: ENDPOINT_BUFFERING = 1; + */ + ENDPOINT_BUFFERING = 1, + + /** + * @generated from enum value: ENDPOINT_PUBLISHING = 2; + */ + ENDPOINT_PUBLISHING = 2, + + /** + * @generated from enum value: ENDPOINT_ERROR = 3; + */ + ENDPOINT_ERROR = 3, + + /** + * @generated from enum value: ENDPOINT_COMPLETE = 4; + */ + ENDPOINT_COMPLETE = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(IngressState_Status) +proto3.util.setEnumType(IngressState_Status, "livekit.IngressState.Status", [ + { no: 0, name: "ENDPOINT_INACTIVE" }, + { no: 1, name: "ENDPOINT_BUFFERING" }, + { no: 2, name: "ENDPOINT_PUBLISHING" }, + { no: 3, name: "ENDPOINT_ERROR" }, + { no: 4, name: "ENDPOINT_COMPLETE" }, +]); + +/** + * @generated from message livekit.InputVideoState + */ +export class InputVideoState extends Message { + /** + * @generated from field: string mime_type = 1; + */ + mimeType = ""; + + /** + * @generated from field: uint32 average_bitrate = 2; + */ + averageBitrate = 0; + + /** + * @generated from field: uint32 width = 3; + */ + width = 0; + + /** + * @generated from field: uint32 height = 4; + */ + height = 0; + + /** + * @generated from field: double framerate = 5; + */ + framerate = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.InputVideoState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "average_bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "framerate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): InputVideoState { + return new InputVideoState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): InputVideoState { + return new InputVideoState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): InputVideoState { + return new InputVideoState().fromJsonString(jsonString, options); + } + + static equals(a: InputVideoState | PlainMessage | undefined, b: InputVideoState | PlainMessage | undefined): boolean { + return proto3.util.equals(InputVideoState, a, b); + } +} + +/** + * @generated from message livekit.InputAudioState + */ +export class InputAudioState extends Message { + /** + * @generated from field: string mime_type = 1; + */ + mimeType = ""; + + /** + * @generated from field: uint32 average_bitrate = 2; + */ + averageBitrate = 0; + + /** + * @generated from field: uint32 channels = 3; + */ + channels = 0; + + /** + * @generated from field: uint32 sample_rate = 4; + */ + sampleRate = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.InputAudioState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "average_bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "channels", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "sample_rate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): InputAudioState { + return new InputAudioState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): InputAudioState { + return new InputAudioState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): InputAudioState { + return new InputAudioState().fromJsonString(jsonString, options); + } + + static equals(a: InputAudioState | PlainMessage | undefined, b: InputAudioState | PlainMessage | undefined): boolean { + return proto3.util.equals(InputAudioState, a, b); + } +} + +/** + * @generated from message livekit.UpdateIngressRequest + */ +export class UpdateIngressRequest extends Message { + /** + * @generated from field: string ingress_id = 1; + */ + ingressId = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * @generated from field: string room_name = 3; + */ + roomName = ""; + + /** + * @generated from field: string participant_identity = 4; + */ + participantIdentity = ""; + + /** + * @generated from field: string participant_name = 5; + */ + participantName = ""; + + /** + * @generated from field: string participant_metadata = 9; + */ + participantMetadata = ""; + + /** + * @generated from field: optional bool bypass_transcoding = 8 [deprecated = true]; + * @deprecated + */ + bypassTranscoding?: boolean; + + /** + * @generated from field: optional bool enable_transcoding = 10; + */ + enableTranscoding?: boolean; + + /** + * @generated from field: livekit.IngressAudioOptions audio = 6; + */ + audio?: IngressAudioOptions; + + /** + * @generated from field: livekit.IngressVideoOptions video = 7; + */ + video?: IngressVideoOptions; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateIngressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "participant_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "participant_metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "bypass_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 10, name: "enable_transcoding", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 6, name: "audio", kind: "message", T: IngressAudioOptions }, + { no: 7, name: "video", kind: "message", T: IngressVideoOptions }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateIngressRequest { + return new UpdateIngressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateIngressRequest { + return new UpdateIngressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateIngressRequest { + return new UpdateIngressRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateIngressRequest | PlainMessage | undefined, b: UpdateIngressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateIngressRequest, a, b); + } +} + +/** + * @generated from message livekit.ListIngressRequest + */ +export class ListIngressRequest extends Message { + /** + * when blank, lists all ingress endpoints + * + * (optional, filter by room name) + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * (optional, filter by ingress ID) + * + * @generated from field: string ingress_id = 2; + */ + ingressId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListIngressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListIngressRequest { + return new ListIngressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListIngressRequest { + return new ListIngressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListIngressRequest { + return new ListIngressRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListIngressRequest | PlainMessage | undefined, b: ListIngressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListIngressRequest, a, b); + } +} + +/** + * @generated from message livekit.ListIngressResponse + */ +export class ListIngressResponse extends Message { + /** + * @generated from field: repeated livekit.IngressInfo items = 1; + */ + items: IngressInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListIngressResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: IngressInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListIngressResponse { + return new ListIngressResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListIngressResponse { + return new ListIngressResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListIngressResponse { + return new ListIngressResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListIngressResponse | PlainMessage | undefined, b: ListIngressResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListIngressResponse, a, b); + } +} + +/** + * @generated from message livekit.DeleteIngressRequest + */ +export class DeleteIngressRequest extends Message { + /** + * @generated from field: string ingress_id = 1; + */ + ingressId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteIngressRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteIngressRequest { + return new DeleteIngressRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteIngressRequest { + return new DeleteIngressRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteIngressRequest { + return new DeleteIngressRequest().fromJsonString(jsonString, options); + } + + static equals(a: DeleteIngressRequest | PlainMessage | undefined, b: DeleteIngressRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteIngressRequest, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_internal_pb.ts b/packages/javascript/src/gen/livekit_internal_pb.ts new file mode 100644 index 00000000..53547d71 --- /dev/null +++ b/packages/javascript/src/gen/livekit_internal_pb.ts @@ -0,0 +1,783 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_internal.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { ClientInfo, PlayoutDelay, ReconnectReason } from "./livekit_models_pb.js"; +import { CreateRoomRequest } from "./livekit_room_pb.js"; +import { AutoParticipantEgress, AutoTrackEgress } from "./livekit_egress_pb.js"; +import { RoomAgentDispatch } from "./livekit_agent_dispatch_pb.js"; + +/** + * @generated from enum livekit.NodeType + */ +export enum NodeType { + /** + * @generated from enum value: SERVER = 0; + */ + SERVER = 0, + + /** + * @generated from enum value: CONTROLLER = 1; + */ + CONTROLLER = 1, + + /** + * @generated from enum value: MEDIA = 2; + */ + MEDIA = 2, + + /** + * @generated from enum value: TURN = 4; + */ + TURN = 4, + + /** + * @generated from enum value: SWEEPER = 5; + */ + SWEEPER = 5, + + /** + * @generated from enum value: DIRECTOR = 6; + */ + DIRECTOR = 6, +} +// Retrieve enum metadata with: proto3.getEnumType(NodeType) +proto3.util.setEnumType(NodeType, "livekit.NodeType", [ + { no: 0, name: "SERVER" }, + { no: 1, name: "CONTROLLER" }, + { no: 2, name: "MEDIA" }, + { no: 4, name: "TURN" }, + { no: 5, name: "SWEEPER" }, + { no: 6, name: "DIRECTOR" }, +]); + +/** + * @generated from enum livekit.NodeState + */ +export enum NodeState { + /** + * @generated from enum value: STARTING_UP = 0; + */ + STARTING_UP = 0, + + /** + * @generated from enum value: SERVING = 1; + */ + SERVING = 1, + + /** + * @generated from enum value: SHUTTING_DOWN = 2; + */ + SHUTTING_DOWN = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(NodeState) +proto3.util.setEnumType(NodeState, "livekit.NodeState", [ + { no: 0, name: "STARTING_UP" }, + { no: 1, name: "SERVING" }, + { no: 2, name: "SHUTTING_DOWN" }, +]); + +/** + * @generated from enum livekit.ICECandidateType + */ +export enum ICECandidateType { + /** + * @generated from enum value: ICT_NONE = 0; + */ + ICT_NONE = 0, + + /** + * @generated from enum value: ICT_TCP = 1; + */ + ICT_TCP = 1, + + /** + * @generated from enum value: ICT_TLS = 2; + */ + ICT_TLS = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(ICECandidateType) +proto3.util.setEnumType(ICECandidateType, "livekit.ICECandidateType", [ + { no: 0, name: "ICT_NONE" }, + { no: 1, name: "ICT_TCP" }, + { no: 2, name: "ICT_TLS" }, +]); + +/** + * @generated from message livekit.Node + */ +export class Node extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string ip = 2; + */ + ip = ""; + + /** + * @generated from field: uint32 num_cpus = 3; + */ + numCpus = 0; + + /** + * @generated from field: livekit.NodeStats stats = 4; + */ + stats?: NodeStats; + + /** + * @generated from field: livekit.NodeType type = 5; + */ + type = NodeType.SERVER; + + /** + * @generated from field: livekit.NodeState state = 6; + */ + state = NodeState.STARTING_UP; + + /** + * @generated from field: string region = 7; + */ + region = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Node"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "ip", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "num_cpus", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "stats", kind: "message", T: NodeStats }, + { no: 5, name: "type", kind: "enum", T: proto3.getEnumType(NodeType) }, + { no: 6, name: "state", kind: "enum", T: proto3.getEnumType(NodeState) }, + { no: 7, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Node { + return new Node().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Node { + return new Node().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Node { + return new Node().fromJsonString(jsonString, options); + } + + static equals(a: Node | PlainMessage | undefined, b: Node | PlainMessage | undefined): boolean { + return proto3.util.equals(Node, a, b); + } +} + +/** + * @generated from message livekit.NodeStats + */ +export class NodeStats extends Message { + /** + * when server was started + * + * @generated from field: int64 started_at = 1; + */ + startedAt = protoInt64.zero; + + /** + * when server last reported its status + * + * @generated from field: int64 updated_at = 2; + */ + updatedAt = protoInt64.zero; + + /** + * room + * + * @generated from field: int32 num_rooms = 3; + */ + numRooms = 0; + + /** + * @generated from field: int32 num_clients = 4; + */ + numClients = 0; + + /** + * @generated from field: int32 num_tracks_in = 5; + */ + numTracksIn = 0; + + /** + * @generated from field: int32 num_tracks_out = 6; + */ + numTracksOut = 0; + + /** + * @generated from field: int32 num_track_publish_attempts = 36; + */ + numTrackPublishAttempts = 0; + + /** + * @generated from field: float track_publish_attempts_per_sec = 37; + */ + trackPublishAttemptsPerSec = 0; + + /** + * @generated from field: int32 num_track_publish_success = 38; + */ + numTrackPublishSuccess = 0; + + /** + * @generated from field: float track_publish_success_per_sec = 39; + */ + trackPublishSuccessPerSec = 0; + + /** + * @generated from field: int32 num_track_subscribe_attempts = 40; + */ + numTrackSubscribeAttempts = 0; + + /** + * @generated from field: float track_subscribe_attempts_per_sec = 41; + */ + trackSubscribeAttemptsPerSec = 0; + + /** + * @generated from field: int32 num_track_subscribe_success = 42; + */ + numTrackSubscribeSuccess = 0; + + /** + * @generated from field: float track_subscribe_success_per_sec = 43; + */ + trackSubscribeSuccessPerSec = 0; + + /** + * packet + * + * @generated from field: uint64 bytes_in = 7; + */ + bytesIn = protoInt64.zero; + + /** + * @generated from field: uint64 bytes_out = 8; + */ + bytesOut = protoInt64.zero; + + /** + * @generated from field: uint64 packets_in = 9; + */ + packetsIn = protoInt64.zero; + + /** + * @generated from field: uint64 packets_out = 10; + */ + packetsOut = protoInt64.zero; + + /** + * @generated from field: uint64 nack_total = 11; + */ + nackTotal = protoInt64.zero; + + /** + * @generated from field: float bytes_in_per_sec = 12; + */ + bytesInPerSec = 0; + + /** + * @generated from field: float bytes_out_per_sec = 13; + */ + bytesOutPerSec = 0; + + /** + * @generated from field: float packets_in_per_sec = 14; + */ + packetsInPerSec = 0; + + /** + * @generated from field: float packets_out_per_sec = 15; + */ + packetsOutPerSec = 0; + + /** + * @generated from field: float nack_per_sec = 16; + */ + nackPerSec = 0; + + /** + * system + * + * @generated from field: uint32 num_cpus = 17; + */ + numCpus = 0; + + /** + * @generated from field: float load_avg_last1min = 18; + */ + loadAvgLast1min = 0; + + /** + * @generated from field: float load_avg_last5min = 19; + */ + loadAvgLast5min = 0; + + /** + * @generated from field: float load_avg_last15min = 20; + */ + loadAvgLast15min = 0; + + /** + * @generated from field: float cpu_load = 21; + */ + cpuLoad = 0; + + /** + * deprecated + * + * @generated from field: float memory_load = 33; + */ + memoryLoad = 0; + + /** + * @generated from field: uint64 memory_total = 34; + */ + memoryTotal = protoInt64.zero; + + /** + * @generated from field: uint64 memory_used = 35; + */ + memoryUsed = protoInt64.zero; + + /** + * @generated from field: uint32 sys_packets_out = 28; + */ + sysPacketsOut = 0; + + /** + * @generated from field: uint32 sys_packets_dropped = 29; + */ + sysPacketsDropped = 0; + + /** + * @generated from field: float sys_packets_out_per_sec = 30; + */ + sysPacketsOutPerSec = 0; + + /** + * @generated from field: float sys_packets_dropped_per_sec = 31; + */ + sysPacketsDroppedPerSec = 0; + + /** + * @generated from field: float sys_packets_dropped_pct_per_sec = 32; + */ + sysPacketsDroppedPctPerSec = 0; + + /** + * retransmissions + * + * @generated from field: uint64 retransmit_bytes_out = 22; + */ + retransmitBytesOut = protoInt64.zero; + + /** + * @generated from field: uint64 retransmit_packets_out = 23; + */ + retransmitPacketsOut = protoInt64.zero; + + /** + * @generated from field: float retransmit_bytes_out_per_sec = 24; + */ + retransmitBytesOutPerSec = 0; + + /** + * @generated from field: float retransmit_packets_out_per_sec = 25; + */ + retransmitPacketsOutPerSec = 0; + + /** + * participant joins + * + * @generated from field: uint64 participant_signal_connected = 26; + */ + participantSignalConnected = protoInt64.zero; + + /** + * @generated from field: float participant_signal_connected_per_sec = 27; + */ + participantSignalConnectedPerSec = 0; + + /** + * @generated from field: uint64 participant_rtc_connected = 44; + */ + participantRtcConnected = protoInt64.zero; + + /** + * @generated from field: float participant_rtc_connected_per_sec = 45; + */ + participantRtcConnectedPerSec = 0; + + /** + * @generated from field: uint64 participant_rtc_init = 46; + */ + participantRtcInit = protoInt64.zero; + + /** + * @generated from field: float participant_rtc_init_per_sec = 47; + */ + participantRtcInitPerSec = 0; + + /** + * forward metrics + * + * @generated from field: uint32 forward_latency = 48; + */ + forwardLatency = 0; + + /** + * @generated from field: uint32 forward_jitter = 49; + */ + forwardJitter = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.NodeStats"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "updated_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "num_rooms", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "num_clients", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 5, name: "num_tracks_in", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 6, name: "num_tracks_out", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 36, name: "num_track_publish_attempts", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 37, name: "track_publish_attempts_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 38, name: "num_track_publish_success", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 39, name: "track_publish_success_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 40, name: "num_track_subscribe_attempts", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 41, name: "track_subscribe_attempts_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 42, name: "num_track_subscribe_success", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 43, name: "track_subscribe_success_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 7, name: "bytes_in", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 8, name: "bytes_out", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 9, name: "packets_in", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 10, name: "packets_out", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 11, name: "nack_total", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 12, name: "bytes_in_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 13, name: "bytes_out_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 14, name: "packets_in_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 15, name: "packets_out_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 16, name: "nack_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 17, name: "num_cpus", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 18, name: "load_avg_last1min", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 19, name: "load_avg_last5min", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 20, name: "load_avg_last15min", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 21, name: "cpu_load", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 33, name: "memory_load", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 34, name: "memory_total", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 35, name: "memory_used", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 28, name: "sys_packets_out", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 29, name: "sys_packets_dropped", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 30, name: "sys_packets_out_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 31, name: "sys_packets_dropped_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 32, name: "sys_packets_dropped_pct_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 22, name: "retransmit_bytes_out", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 23, name: "retransmit_packets_out", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 24, name: "retransmit_bytes_out_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 25, name: "retransmit_packets_out_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 26, name: "participant_signal_connected", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 27, name: "participant_signal_connected_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 44, name: "participant_rtc_connected", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 45, name: "participant_rtc_connected_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 46, name: "participant_rtc_init", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 47, name: "participant_rtc_init_per_sec", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 48, name: "forward_latency", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 49, name: "forward_jitter", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): NodeStats { + return new NodeStats().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): NodeStats { + return new NodeStats().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): NodeStats { + return new NodeStats().fromJsonString(jsonString, options); + } + + static equals(a: NodeStats | PlainMessage | undefined, b: NodeStats | PlainMessage | undefined): boolean { + return proto3.util.equals(NodeStats, a, b); + } +} + +/** + * @generated from message livekit.StartSession + */ +export class StartSession extends Message { + /** + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * @generated from field: string connection_id = 3; + */ + connectionId = ""; + + /** + * if a client is reconnecting (i.e. resume instead of restart) + * + * @generated from field: bool reconnect = 4; + */ + reconnect = false; + + /** + * @generated from field: bool auto_subscribe = 9; + */ + autoSubscribe = false; + + /** + * @generated from field: bool hidden = 10; + */ + hidden = false; + + /** + * @generated from field: livekit.ClientInfo client = 11; + */ + client?: ClientInfo; + + /** + * @generated from field: bool recorder = 12; + */ + recorder = false; + + /** + * @generated from field: string name = 13; + */ + name = ""; + + /** + * A user's ClaimGrants serialized in JSON + * + * @generated from field: string grants_json = 14; + */ + grantsJson = ""; + + /** + * @generated from field: bool adaptive_stream = 15; + */ + adaptiveStream = false; + + /** + * if reconnect, client will set current sid + * + * @generated from field: string participant_id = 16; + */ + participantId = ""; + + /** + * @generated from field: livekit.ReconnectReason reconnect_reason = 17; + */ + reconnectReason = ReconnectReason.RR_UNKNOWN; + + /** + * @generated from field: optional bool subscriber_allow_pause = 18; + */ + subscriberAllowPause?: boolean; + + /** + * @generated from field: bool disable_ice_lite = 19; + */ + disableIceLite = false; + + /** + * @generated from field: livekit.CreateRoomRequest create_room = 20; + */ + createRoom?: CreateRoomRequest; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StartSession"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "reconnect", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 9, name: "auto_subscribe", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 10, name: "hidden", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 11, name: "client", kind: "message", T: ClientInfo }, + { no: 12, name: "recorder", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 13, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 14, name: "grants_json", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 15, name: "adaptive_stream", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 16, name: "participant_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 17, name: "reconnect_reason", kind: "enum", T: proto3.getEnumType(ReconnectReason) }, + { no: 18, name: "subscriber_allow_pause", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 19, name: "disable_ice_lite", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 20, name: "create_room", kind: "message", T: CreateRoomRequest }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StartSession { + return new StartSession().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StartSession { + return new StartSession().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StartSession { + return new StartSession().fromJsonString(jsonString, options); + } + + static equals(a: StartSession | PlainMessage | undefined, b: StartSession | PlainMessage | undefined): boolean { + return proto3.util.equals(StartSession, a, b); + } +} + +/** + * room info that should not be returned to clients + * + * @generated from message livekit.RoomInternal + */ +export class RoomInternal extends Message { + /** + * @generated from field: livekit.AutoTrackEgress track_egress = 1; + */ + trackEgress?: AutoTrackEgress; + + /** + * @generated from field: livekit.AutoParticipantEgress participant_egress = 2; + */ + participantEgress?: AutoParticipantEgress; + + /** + * @generated from field: livekit.PlayoutDelay playout_delay = 3; + */ + playoutDelay?: PlayoutDelay; + + /** + * @generated from field: repeated livekit.RoomAgentDispatch agent_dispatches = 5; + */ + agentDispatches: RoomAgentDispatch[] = []; + + /** + * @generated from field: bool sync_streams = 4; + */ + syncStreams = false; + + /** + * @generated from field: bool replay_enabled = 6; + */ + replayEnabled = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomInternal"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_egress", kind: "message", T: AutoTrackEgress }, + { no: 2, name: "participant_egress", kind: "message", T: AutoParticipantEgress }, + { no: 3, name: "playout_delay", kind: "message", T: PlayoutDelay }, + { no: 5, name: "agent_dispatches", kind: "message", T: RoomAgentDispatch, repeated: true }, + { no: 4, name: "sync_streams", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "replay_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomInternal { + return new RoomInternal().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomInternal { + return new RoomInternal().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomInternal { + return new RoomInternal().fromJsonString(jsonString, options); + } + + static equals(a: RoomInternal | PlainMessage | undefined, b: RoomInternal | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomInternal, a, b); + } +} + +/** + * @generated from message livekit.ICEConfig + */ +export class ICEConfig extends Message { + /** + * @generated from field: livekit.ICECandidateType preference_subscriber = 1; + */ + preferenceSubscriber = ICECandidateType.ICT_NONE; + + /** + * @generated from field: livekit.ICECandidateType preference_publisher = 2; + */ + preferencePublisher = ICECandidateType.ICT_NONE; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ICEConfig"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "preference_subscriber", kind: "enum", T: proto3.getEnumType(ICECandidateType) }, + { no: 2, name: "preference_publisher", kind: "enum", T: proto3.getEnumType(ICECandidateType) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ICEConfig { + return new ICEConfig().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ICEConfig { + return new ICEConfig().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ICEConfig { + return new ICEConfig().fromJsonString(jsonString, options); + } + + static equals(a: ICEConfig | PlainMessage | undefined, b: ICEConfig | PlainMessage | undefined): boolean { + return proto3.util.equals(ICEConfig, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_metrics_pb.ts b/packages/javascript/src/gen/livekit_metrics_pb.ts new file mode 100644 index 00000000..dc32bd8c --- /dev/null +++ b/packages/javascript/src/gen/livekit_metrics_pb.ts @@ -0,0 +1,446 @@ +// @generated by protoc-gen-es v1.10.0 with parameter "target=ts" +// @generated from file livekit_metrics.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf"; + +/** + * index from [0: MAX_LABEL_PREDEFINED_MAX_VALUE) are for predefined labels (`MetricLabel`) + * + * @generated from enum livekit.MetricLabel + */ +export enum MetricLabel { + /** + * time to first token from LLM + * + * @generated from enum value: AGENTS_LLM_TTFT = 0; + */ + AGENTS_LLM_TTFT = 0, + + /** + * time to final transcription + * + * @generated from enum value: AGENTS_STT_TTFT = 1; + */ + AGENTS_STT_TTFT = 1, + + /** + * time to first byte + * + * @generated from enum value: AGENTS_TTS_TTFB = 2; + */ + AGENTS_TTS_TTFB = 2, + + /** + * Number of video freezes + * + * @generated from enum value: CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT = 3; + */ + CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT = 3, + + /** + * total duration of freezes + * + * @generated from enum value: CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION = 4; + */ + CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION = 4, + + /** + * number of video pauses + * + * @generated from enum value: CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT = 5; + */ + CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT = 5, + + /** + * total duration of pauses + * + * @generated from enum value: CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION = 6; + */ + CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION = 6, + + /** + * number of concealed (synthesized) audio samples + * + * @generated from enum value: CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES = 7; + */ + CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES = 7, + + /** + * number of silent concealed samples + * + * @generated from enum value: CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES = 8; + */ + CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES = 8, + + /** + * number of concealment events + * + * @generated from enum value: CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS = 9; + */ + CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS = 9, + + /** + * number of interruptions + * + * @generated from enum value: CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT = 10; + */ + CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT = 10, + + /** + * total duration of interruptions + * + * @generated from enum value: CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION = 11; + */ + CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION = 11, + + /** + * total time spent in jitter buffer + * + * @generated from enum value: CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY = 12; + */ + CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY = 12, + + /** + * total time spent in jitter buffer + * + * @generated from enum value: CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT = 13; + */ + CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT = 13, + + /** + * total duration spent in bandwidth quality limitation + * + * @generated from enum value: CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH = 14; + */ + CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH = 14, + + /** + * total duration spent in cpu quality limitation + * + * @generated from enum value: CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU = 15; + */ + CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU = 15, + + /** + * total duration spent in other quality limitation + * + * @generated from enum value: CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER = 16; + */ + CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER = 16, + + /** + * @generated from enum value: METRIC_LABEL_PREDEFINED_MAX_VALUE = 4096; + */ + METRIC_LABEL_PREDEFINED_MAX_VALUE = 4096, +} +// Retrieve enum metadata with: proto3.getEnumType(MetricLabel) +proto3.util.setEnumType(MetricLabel, "livekit.MetricLabel", [ + { no: 0, name: "AGENTS_LLM_TTFT" }, + { no: 1, name: "AGENTS_STT_TTFT" }, + { no: 2, name: "AGENTS_TTS_TTFB" }, + { no: 3, name: "CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT" }, + { no: 4, name: "CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION" }, + { no: 5, name: "CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT" }, + { no: 6, name: "CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION" }, + { no: 7, name: "CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES" }, + { no: 8, name: "CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES" }, + { no: 9, name: "CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS" }, + { no: 10, name: "CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT" }, + { no: 11, name: "CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION" }, + { no: 12, name: "CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY" }, + { no: 13, name: "CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT" }, + { no: 14, name: "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH" }, + { no: 15, name: "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU" }, + { no: 16, name: "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER" }, + { no: 4096, name: "METRIC_LABEL_PREDEFINED_MAX_VALUE" }, +]); + +/** + * @generated from message livekit.MetricsBatch + */ +export class MetricsBatch extends Message { + /** + * time at which this batch is sent based on a monotonic clock (millisecond resolution) + * + * @generated from field: int64 timestamp_ms = 1; + */ + timestampMs = protoInt64.zero; + + /** + * @generated from field: google.protobuf.Timestamp normalized_timestamp = 2; + */ + normalizedTimestamp?: Timestamp; + + /** + * To avoid repeating string values, we store them in a separate list and reference them by index + * This is useful for storing participant identities, track names, etc. + * There is also a predefined list of labels that can be used to reference common metrics. + * They have reserved indices from 0 to (METRIC_LABEL_PREDEFINED_MAX_VALUE - 1). + * Indexes pointing at str_data should start from METRIC_LABEL_PREDEFINED_MAX_VALUE, + * such that str_data[0] == index of METRIC_LABEL_PREDEFINED_MAX_VALUE. + * + * @generated from field: repeated string str_data = 3; + */ + strData: string[] = []; + + /** + * @generated from field: repeated livekit.TimeSeriesMetric time_series = 4; + */ + timeSeries: TimeSeriesMetric[] = []; + + /** + * @generated from field: repeated livekit.EventMetric events = 5; + */ + events: EventMetric[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MetricsBatch"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp_ms", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "normalized_timestamp", kind: "message", T: Timestamp }, + { no: 3, name: "str_data", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "time_series", kind: "message", T: TimeSeriesMetric, repeated: true }, + { no: 5, name: "events", kind: "message", T: EventMetric, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MetricsBatch { + return new MetricsBatch().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MetricsBatch { + return new MetricsBatch().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MetricsBatch { + return new MetricsBatch().fromJsonString(jsonString, options); + } + + static equals(a: MetricsBatch | PlainMessage | undefined, b: MetricsBatch | PlainMessage | undefined): boolean { + return proto3.util.equals(MetricsBatch, a, b); + } +} + +/** + * @generated from message livekit.TimeSeriesMetric + */ +export class TimeSeriesMetric extends Message { + /** + * Metric name e.g "speech_probablity". The string value is not directly stored in the message, but referenced by index + * in the `str_data` field of `MetricsBatch` + * + * @generated from field: uint32 label = 1; + */ + label = 0; + + /** + * index into `str_data` + * + * @generated from field: uint32 participant_identity = 2; + */ + participantIdentity = 0; + + /** + * index into `str_data` + * + * @generated from field: uint32 track_sid = 3; + */ + trackSid = 0; + + /** + * @generated from field: repeated livekit.MetricSample samples = 4; + */ + samples: MetricSample[] = []; + + /** + * index into 'str_data' + * + * @generated from field: uint32 rid = 5; + */ + rid = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TimeSeriesMetric"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "label", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "participant_identity", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "track_sid", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "samples", kind: "message", T: MetricSample, repeated: true }, + { no: 5, name: "rid", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TimeSeriesMetric { + return new TimeSeriesMetric().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TimeSeriesMetric { + return new TimeSeriesMetric().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TimeSeriesMetric { + return new TimeSeriesMetric().fromJsonString(jsonString, options); + } + + static equals(a: TimeSeriesMetric | PlainMessage | undefined, b: TimeSeriesMetric | PlainMessage | undefined): boolean { + return proto3.util.equals(TimeSeriesMetric, a, b); + } +} + +/** + * @generated from message livekit.MetricSample + */ +export class MetricSample extends Message { + /** + * time of metric based on a monotonic clock (in milliseconds) + * + * @generated from field: int64 timestamp_ms = 1; + */ + timestampMs = protoInt64.zero; + + /** + * @generated from field: google.protobuf.Timestamp normalized_timestamp = 2; + */ + normalizedTimestamp?: Timestamp; + + /** + * @generated from field: float value = 3; + */ + value = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MetricSample"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp_ms", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "normalized_timestamp", kind: "message", T: Timestamp }, + { no: 3, name: "value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MetricSample { + return new MetricSample().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MetricSample { + return new MetricSample().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MetricSample { + return new MetricSample().fromJsonString(jsonString, options); + } + + static equals(a: MetricSample | PlainMessage | undefined, b: MetricSample | PlainMessage | undefined): boolean { + return proto3.util.equals(MetricSample, a, b); + } +} + +/** + * @generated from message livekit.EventMetric + */ +export class EventMetric extends Message { + /** + * @generated from field: uint32 label = 1; + */ + label = 0; + + /** + * index into `str_data` + * + * @generated from field: uint32 participant_identity = 2; + */ + participantIdentity = 0; + + /** + * index into `str_data` + * + * @generated from field: uint32 track_sid = 3; + */ + trackSid = 0; + + /** + * start time of event based on a monotonic clock (in milliseconds) + * + * @generated from field: int64 start_timestamp_ms = 4; + */ + startTimestampMs = protoInt64.zero; + + /** + * end time of event based on a monotonic clock (in milliseconds), if needed + * + * @generated from field: optional int64 end_timestamp_ms = 5; + */ + endTimestampMs?: bigint; + + /** + * @generated from field: google.protobuf.Timestamp normalized_start_timestamp = 6; + */ + normalizedStartTimestamp?: Timestamp; + + /** + * @generated from field: optional google.protobuf.Timestamp normalized_end_timestamp = 7; + */ + normalizedEndTimestamp?: Timestamp; + + /** + * @generated from field: string metadata = 8; + */ + metadata = ""; + + /** + * index into 'str_data' + * + * @generated from field: uint32 rid = 9; + */ + rid = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.EventMetric"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "label", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "participant_identity", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "track_sid", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "start_timestamp_ms", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 5, name: "end_timestamp_ms", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true }, + { no: 6, name: "normalized_start_timestamp", kind: "message", T: Timestamp }, + { no: 7, name: "normalized_end_timestamp", kind: "message", T: Timestamp, opt: true }, + { no: 8, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "rid", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EventMetric { + return new EventMetric().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EventMetric { + return new EventMetric().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EventMetric { + return new EventMetric().fromJsonString(jsonString, options); + } + + static equals(a: EventMetric | PlainMessage | undefined, b: EventMetric | PlainMessage | undefined): boolean { + return proto3.util.equals(EventMetric, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_models_pb.ts b/packages/javascript/src/gen/livekit_models_pb.ts new file mode 100644 index 00000000..8f5a7ddf --- /dev/null +++ b/packages/javascript/src/gen/livekit_models_pb.ts @@ -0,0 +1,3329 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_models.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf"; +import { MetricsBatch } from "./livekit_metrics_pb.js"; + +/** + * @generated from enum livekit.AudioCodec + */ +export enum AudioCodec { + /** + * @generated from enum value: DEFAULT_AC = 0; + */ + DEFAULT_AC = 0, + + /** + * @generated from enum value: OPUS = 1; + */ + OPUS = 1, + + /** + * @generated from enum value: AAC = 2; + */ + AAC = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(AudioCodec) +proto3.util.setEnumType(AudioCodec, "livekit.AudioCodec", [ + { no: 0, name: "DEFAULT_AC" }, + { no: 1, name: "OPUS" }, + { no: 2, name: "AAC" }, +]); + +/** + * @generated from enum livekit.VideoCodec + */ +export enum VideoCodec { + /** + * @generated from enum value: DEFAULT_VC = 0; + */ + DEFAULT_VC = 0, + + /** + * @generated from enum value: H264_BASELINE = 1; + */ + H264_BASELINE = 1, + + /** + * @generated from enum value: H264_MAIN = 2; + */ + H264_MAIN = 2, + + /** + * @generated from enum value: H264_HIGH = 3; + */ + H264_HIGH = 3, + + /** + * @generated from enum value: VP8 = 4; + */ + VP8 = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(VideoCodec) +proto3.util.setEnumType(VideoCodec, "livekit.VideoCodec", [ + { no: 0, name: "DEFAULT_VC" }, + { no: 1, name: "H264_BASELINE" }, + { no: 2, name: "H264_MAIN" }, + { no: 3, name: "H264_HIGH" }, + { no: 4, name: "VP8" }, +]); + +/** + * @generated from enum livekit.ImageCodec + */ +export enum ImageCodec { + /** + * @generated from enum value: IC_DEFAULT = 0; + */ + IC_DEFAULT = 0, + + /** + * @generated from enum value: IC_JPEG = 1; + */ + IC_JPEG = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(ImageCodec) +proto3.util.setEnumType(ImageCodec, "livekit.ImageCodec", [ + { no: 0, name: "IC_DEFAULT" }, + { no: 1, name: "IC_JPEG" }, +]); + +/** + * @generated from enum livekit.TrackType + */ +export enum TrackType { + /** + * @generated from enum value: AUDIO = 0; + */ + AUDIO = 0, + + /** + * @generated from enum value: VIDEO = 1; + */ + VIDEO = 1, + + /** + * @generated from enum value: DATA = 2; + */ + DATA = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(TrackType) +proto3.util.setEnumType(TrackType, "livekit.TrackType", [ + { no: 0, name: "AUDIO" }, + { no: 1, name: "VIDEO" }, + { no: 2, name: "DATA" }, +]); + +/** + * @generated from enum livekit.TrackSource + */ +export enum TrackSource { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: CAMERA = 1; + */ + CAMERA = 1, + + /** + * @generated from enum value: MICROPHONE = 2; + */ + MICROPHONE = 2, + + /** + * @generated from enum value: SCREEN_SHARE = 3; + */ + SCREEN_SHARE = 3, + + /** + * @generated from enum value: SCREEN_SHARE_AUDIO = 4; + */ + SCREEN_SHARE_AUDIO = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(TrackSource) +proto3.util.setEnumType(TrackSource, "livekit.TrackSource", [ + { no: 0, name: "UNKNOWN" }, + { no: 1, name: "CAMERA" }, + { no: 2, name: "MICROPHONE" }, + { no: 3, name: "SCREEN_SHARE" }, + { no: 4, name: "SCREEN_SHARE_AUDIO" }, +]); + +/** + * @generated from enum livekit.VideoQuality + */ +export enum VideoQuality { + /** + * @generated from enum value: LOW = 0; + */ + LOW = 0, + + /** + * @generated from enum value: MEDIUM = 1; + */ + MEDIUM = 1, + + /** + * @generated from enum value: HIGH = 2; + */ + HIGH = 2, + + /** + * @generated from enum value: OFF = 3; + */ + OFF = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(VideoQuality) +proto3.util.setEnumType(VideoQuality, "livekit.VideoQuality", [ + { no: 0, name: "LOW" }, + { no: 1, name: "MEDIUM" }, + { no: 2, name: "HIGH" }, + { no: 3, name: "OFF" }, +]); + +/** + * @generated from enum livekit.ConnectionQuality + */ +export enum ConnectionQuality { + /** + * @generated from enum value: POOR = 0; + */ + POOR = 0, + + /** + * @generated from enum value: GOOD = 1; + */ + GOOD = 1, + + /** + * @generated from enum value: EXCELLENT = 2; + */ + EXCELLENT = 2, + + /** + * @generated from enum value: LOST = 3; + */ + LOST = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(ConnectionQuality) +proto3.util.setEnumType(ConnectionQuality, "livekit.ConnectionQuality", [ + { no: 0, name: "POOR" }, + { no: 1, name: "GOOD" }, + { no: 2, name: "EXCELLENT" }, + { no: 3, name: "LOST" }, +]); + +/** + * @generated from enum livekit.ClientConfigSetting + */ +export enum ClientConfigSetting { + /** + * @generated from enum value: UNSET = 0; + */ + UNSET = 0, + + /** + * @generated from enum value: DISABLED = 1; + */ + DISABLED = 1, + + /** + * @generated from enum value: ENABLED = 2; + */ + ENABLED = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(ClientConfigSetting) +proto3.util.setEnumType(ClientConfigSetting, "livekit.ClientConfigSetting", [ + { no: 0, name: "UNSET" }, + { no: 1, name: "DISABLED" }, + { no: 2, name: "ENABLED" }, +]); + +/** + * @generated from enum livekit.DisconnectReason + */ +export enum DisconnectReason { + /** + * @generated from enum value: UNKNOWN_REASON = 0; + */ + UNKNOWN_REASON = 0, + + /** + * the client initiated the disconnect + * + * @generated from enum value: CLIENT_INITIATED = 1; + */ + CLIENT_INITIATED = 1, + + /** + * another participant with the same identity has joined the room + * + * @generated from enum value: DUPLICATE_IDENTITY = 2; + */ + DUPLICATE_IDENTITY = 2, + + /** + * the server instance is shutting down + * + * @generated from enum value: SERVER_SHUTDOWN = 3; + */ + SERVER_SHUTDOWN = 3, + + /** + * RoomService.RemoveParticipant was called + * + * @generated from enum value: PARTICIPANT_REMOVED = 4; + */ + PARTICIPANT_REMOVED = 4, + + /** + * RoomService.DeleteRoom was called + * + * @generated from enum value: ROOM_DELETED = 5; + */ + ROOM_DELETED = 5, + + /** + * the client is attempting to resume a session, but server is not aware of it + * + * @generated from enum value: STATE_MISMATCH = 6; + */ + STATE_MISMATCH = 6, + + /** + * client was unable to connect fully + * + * @generated from enum value: JOIN_FAILURE = 7; + */ + JOIN_FAILURE = 7, + + /** + * Cloud-only, the server requested Participant to migrate the connection elsewhere + * + * @generated from enum value: MIGRATION = 8; + */ + MIGRATION = 8, + + /** + * the signal websocket was closed unexpectedly + * + * @generated from enum value: SIGNAL_CLOSE = 9; + */ + SIGNAL_CLOSE = 9, + + /** + * the room was closed, due to all Standard and Ingress participants having left + * + * @generated from enum value: ROOM_CLOSED = 10; + */ + ROOM_CLOSED = 10, + + /** + * SIP callee did not respond in time + * + * @generated from enum value: USER_UNAVAILABLE = 11; + */ + USER_UNAVAILABLE = 11, + + /** + * SIP callee rejected the call (busy) + * + * @generated from enum value: USER_REJECTED = 12; + */ + USER_REJECTED = 12, + + /** + * SIP protocol failure or unexpected response + * + * @generated from enum value: SIP_TRUNK_FAILURE = 13; + */ + SIP_TRUNK_FAILURE = 13, +} +// Retrieve enum metadata with: proto3.getEnumType(DisconnectReason) +proto3.util.setEnumType(DisconnectReason, "livekit.DisconnectReason", [ + { no: 0, name: "UNKNOWN_REASON" }, + { no: 1, name: "CLIENT_INITIATED" }, + { no: 2, name: "DUPLICATE_IDENTITY" }, + { no: 3, name: "SERVER_SHUTDOWN" }, + { no: 4, name: "PARTICIPANT_REMOVED" }, + { no: 5, name: "ROOM_DELETED" }, + { no: 6, name: "STATE_MISMATCH" }, + { no: 7, name: "JOIN_FAILURE" }, + { no: 8, name: "MIGRATION" }, + { no: 9, name: "SIGNAL_CLOSE" }, + { no: 10, name: "ROOM_CLOSED" }, + { no: 11, name: "USER_UNAVAILABLE" }, + { no: 12, name: "USER_REJECTED" }, + { no: 13, name: "SIP_TRUNK_FAILURE" }, +]); + +/** + * @generated from enum livekit.ReconnectReason + */ +export enum ReconnectReason { + /** + * @generated from enum value: RR_UNKNOWN = 0; + */ + RR_UNKNOWN = 0, + + /** + * @generated from enum value: RR_SIGNAL_DISCONNECTED = 1; + */ + RR_SIGNAL_DISCONNECTED = 1, + + /** + * @generated from enum value: RR_PUBLISHER_FAILED = 2; + */ + RR_PUBLISHER_FAILED = 2, + + /** + * @generated from enum value: RR_SUBSCRIBER_FAILED = 3; + */ + RR_SUBSCRIBER_FAILED = 3, + + /** + * @generated from enum value: RR_SWITCH_CANDIDATE = 4; + */ + RR_SWITCH_CANDIDATE = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(ReconnectReason) +proto3.util.setEnumType(ReconnectReason, "livekit.ReconnectReason", [ + { no: 0, name: "RR_UNKNOWN" }, + { no: 1, name: "RR_SIGNAL_DISCONNECTED" }, + { no: 2, name: "RR_PUBLISHER_FAILED" }, + { no: 3, name: "RR_SUBSCRIBER_FAILED" }, + { no: 4, name: "RR_SWITCH_CANDIDATE" }, +]); + +/** + * @generated from enum livekit.SubscriptionError + */ +export enum SubscriptionError { + /** + * @generated from enum value: SE_UNKNOWN = 0; + */ + SE_UNKNOWN = 0, + + /** + * @generated from enum value: SE_CODEC_UNSUPPORTED = 1; + */ + SE_CODEC_UNSUPPORTED = 1, + + /** + * @generated from enum value: SE_TRACK_NOTFOUND = 2; + */ + SE_TRACK_NOTFOUND = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(SubscriptionError) +proto3.util.setEnumType(SubscriptionError, "livekit.SubscriptionError", [ + { no: 0, name: "SE_UNKNOWN" }, + { no: 1, name: "SE_CODEC_UNSUPPORTED" }, + { no: 2, name: "SE_TRACK_NOTFOUND" }, +]); + +/** + * @generated from enum livekit.AudioTrackFeature + */ +export enum AudioTrackFeature { + /** + * @generated from enum value: TF_STEREO = 0; + */ + TF_STEREO = 0, + + /** + * @generated from enum value: TF_NO_DTX = 1; + */ + TF_NO_DTX = 1, + + /** + * @generated from enum value: TF_AUTO_GAIN_CONTROL = 2; + */ + TF_AUTO_GAIN_CONTROL = 2, + + /** + * @generated from enum value: TF_ECHO_CANCELLATION = 3; + */ + TF_ECHO_CANCELLATION = 3, + + /** + * @generated from enum value: TF_NOISE_SUPPRESSION = 4; + */ + TF_NOISE_SUPPRESSION = 4, + + /** + * @generated from enum value: TF_ENHANCED_NOISE_CANCELLATION = 5; + */ + TF_ENHANCED_NOISE_CANCELLATION = 5, +} +// Retrieve enum metadata with: proto3.getEnumType(AudioTrackFeature) +proto3.util.setEnumType(AudioTrackFeature, "livekit.AudioTrackFeature", [ + { no: 0, name: "TF_STEREO" }, + { no: 1, name: "TF_NO_DTX" }, + { no: 2, name: "TF_AUTO_GAIN_CONTROL" }, + { no: 3, name: "TF_ECHO_CANCELLATION" }, + { no: 4, name: "TF_NOISE_SUPPRESSION" }, + { no: 5, name: "TF_ENHANCED_NOISE_CANCELLATION" }, +]); + +/** + * @generated from message livekit.Room + */ +export class Room extends Message { + /** + * @generated from field: string sid = 1; + */ + sid = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * @generated from field: uint32 empty_timeout = 3; + */ + emptyTimeout = 0; + + /** + * @generated from field: uint32 departure_timeout = 14; + */ + departureTimeout = 0; + + /** + * @generated from field: uint32 max_participants = 4; + */ + maxParticipants = 0; + + /** + * @generated from field: int64 creation_time = 5; + */ + creationTime = protoInt64.zero; + + /** + * @generated from field: string turn_password = 6; + */ + turnPassword = ""; + + /** + * @generated from field: repeated livekit.Codec enabled_codecs = 7; + */ + enabledCodecs: Codec[] = []; + + /** + * @generated from field: string metadata = 8; + */ + metadata = ""; + + /** + * @generated from field: uint32 num_participants = 9; + */ + numParticipants = 0; + + /** + * @generated from field: uint32 num_publishers = 11; + */ + numPublishers = 0; + + /** + * @generated from field: bool active_recording = 10; + */ + activeRecording = false; + + /** + * @generated from field: livekit.TimedVersion version = 13; + */ + version?: TimedVersion; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Room"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "empty_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 14, name: "departure_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "max_participants", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "creation_time", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 6, name: "turn_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "enabled_codecs", kind: "message", T: Codec, repeated: true }, + { no: 8, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "num_participants", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 11, name: "num_publishers", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 10, name: "active_recording", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 13, name: "version", kind: "message", T: TimedVersion }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Room { + return new Room().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Room { + return new Room().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Room { + return new Room().fromJsonString(jsonString, options); + } + + static equals(a: Room | PlainMessage | undefined, b: Room | PlainMessage | undefined): boolean { + return proto3.util.equals(Room, a, b); + } +} + +/** + * @generated from message livekit.Codec + */ +export class Codec extends Message { + /** + * @generated from field: string mime = 1; + */ + mime = ""; + + /** + * @generated from field: string fmtp_line = 2; + */ + fmtpLine = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Codec"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "mime", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "fmtp_line", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Codec { + return new Codec().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Codec { + return new Codec().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Codec { + return new Codec().fromJsonString(jsonString, options); + } + + static equals(a: Codec | PlainMessage | undefined, b: Codec | PlainMessage | undefined): boolean { + return proto3.util.equals(Codec, a, b); + } +} + +/** + * @generated from message livekit.PlayoutDelay + */ +export class PlayoutDelay extends Message { + /** + * @generated from field: bool enabled = 1; + */ + enabled = false; + + /** + * @generated from field: uint32 min = 2; + */ + min = 0; + + /** + * @generated from field: uint32 max = 3; + */ + max = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.PlayoutDelay"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "min", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "max", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): PlayoutDelay { + return new PlayoutDelay().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): PlayoutDelay { + return new PlayoutDelay().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): PlayoutDelay { + return new PlayoutDelay().fromJsonString(jsonString, options); + } + + static equals(a: PlayoutDelay | PlainMessage | undefined, b: PlayoutDelay | PlainMessage | undefined): boolean { + return proto3.util.equals(PlayoutDelay, a, b); + } +} + +/** + * @generated from message livekit.ParticipantPermission + */ +export class ParticipantPermission extends Message { + /** + * allow participant to subscribe to other tracks in the room + * + * @generated from field: bool can_subscribe = 1; + */ + canSubscribe = false; + + /** + * allow participant to publish new tracks to room + * + * @generated from field: bool can_publish = 2; + */ + canPublish = false; + + /** + * allow participant to publish data + * + * @generated from field: bool can_publish_data = 3; + */ + canPublishData = false; + + /** + * sources that are allowed to be published + * + * @generated from field: repeated livekit.TrackSource can_publish_sources = 9; + */ + canPublishSources: TrackSource[] = []; + + /** + * indicates that it's hidden to others + * + * @generated from field: bool hidden = 7; + */ + hidden = false; + + /** + * indicates it's a recorder instance + * deprecated: use ParticipantInfo.kind instead + * + * @generated from field: bool recorder = 8 [deprecated = true]; + * @deprecated + */ + recorder = false; + + /** + * indicates that participant can update own metadata and attributes + * + * @generated from field: bool can_update_metadata = 10; + */ + canUpdateMetadata = false; + + /** + * indicates that participant is an agent + * deprecated: use ParticipantInfo.kind instead + * + * @generated from field: bool agent = 11 [deprecated = true]; + * @deprecated + */ + agent = false; + + /** + * if a participant can subscribe to metrics + * + * @generated from field: bool can_subscribe_metrics = 12; + */ + canSubscribeMetrics = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ParticipantPermission"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "can_subscribe", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "can_publish", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "can_publish_data", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 9, name: "can_publish_sources", kind: "enum", T: proto3.getEnumType(TrackSource), repeated: true }, + { no: 7, name: "hidden", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 8, name: "recorder", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 10, name: "can_update_metadata", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 11, name: "agent", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 12, name: "can_subscribe_metrics", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ParticipantPermission { + return new ParticipantPermission().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ParticipantPermission { + return new ParticipantPermission().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ParticipantPermission { + return new ParticipantPermission().fromJsonString(jsonString, options); + } + + static equals(a: ParticipantPermission | PlainMessage | undefined, b: ParticipantPermission | PlainMessage | undefined): boolean { + return proto3.util.equals(ParticipantPermission, a, b); + } +} + +/** + * @generated from message livekit.ParticipantInfo + */ +export class ParticipantInfo extends Message { + /** + * @generated from field: string sid = 1; + */ + sid = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * @generated from field: livekit.ParticipantInfo.State state = 3; + */ + state = ParticipantInfo_State.JOINING; + + /** + * @generated from field: repeated livekit.TrackInfo tracks = 4; + */ + tracks: TrackInfo[] = []; + + /** + * @generated from field: string metadata = 5; + */ + metadata = ""; + + /** + * timestamp when participant joined room, in seconds + * + * @generated from field: int64 joined_at = 6; + */ + joinedAt = protoInt64.zero; + + /** + * @generated from field: string name = 9; + */ + name = ""; + + /** + * @generated from field: uint32 version = 10; + */ + version = 0; + + /** + * @generated from field: livekit.ParticipantPermission permission = 11; + */ + permission?: ParticipantPermission; + + /** + * @generated from field: string region = 12; + */ + region = ""; + + /** + * indicates the participant has an active publisher connection + * and can publish to the server + * + * @generated from field: bool is_publisher = 13; + */ + isPublisher = false; + + /** + * @generated from field: livekit.ParticipantInfo.Kind kind = 14; + */ + kind = ParticipantInfo_Kind.STANDARD; + + /** + * @generated from field: map attributes = 15; + */ + attributes: { [key: string]: string } = {}; + + /** + * @generated from field: livekit.DisconnectReason disconnect_reason = 16; + */ + disconnectReason = DisconnectReason.UNKNOWN_REASON; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ParticipantInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "state", kind: "enum", T: proto3.getEnumType(ParticipantInfo_State) }, + { no: 4, name: "tracks", kind: "message", T: TrackInfo, repeated: true }, + { no: 5, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "joined_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 9, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "version", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 11, name: "permission", kind: "message", T: ParticipantPermission }, + { no: 12, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 13, name: "is_publisher", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 14, name: "kind", kind: "enum", T: proto3.getEnumType(ParticipantInfo_Kind) }, + { no: 15, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 16, name: "disconnect_reason", kind: "enum", T: proto3.getEnumType(DisconnectReason) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ParticipantInfo { + return new ParticipantInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ParticipantInfo { + return new ParticipantInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ParticipantInfo { + return new ParticipantInfo().fromJsonString(jsonString, options); + } + + static equals(a: ParticipantInfo | PlainMessage | undefined, b: ParticipantInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(ParticipantInfo, a, b); + } +} + +/** + * @generated from enum livekit.ParticipantInfo.State + */ +export enum ParticipantInfo_State { + /** + * websocket' connected, but not offered yet + * + * @generated from enum value: JOINING = 0; + */ + JOINING = 0, + + /** + * server received client offer + * + * @generated from enum value: JOINED = 1; + */ + JOINED = 1, + + /** + * ICE connectivity established + * + * @generated from enum value: ACTIVE = 2; + */ + ACTIVE = 2, + + /** + * WS disconnected + * + * @generated from enum value: DISCONNECTED = 3; + */ + DISCONNECTED = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(ParticipantInfo_State) +proto3.util.setEnumType(ParticipantInfo_State, "livekit.ParticipantInfo.State", [ + { no: 0, name: "JOINING" }, + { no: 1, name: "JOINED" }, + { no: 2, name: "ACTIVE" }, + { no: 3, name: "DISCONNECTED" }, +]); + +/** + * @generated from enum livekit.ParticipantInfo.Kind + */ +export enum ParticipantInfo_Kind { + /** + * standard participants, e.g. web clients + * + * @generated from enum value: STANDARD = 0; + */ + STANDARD = 0, + + /** + * only ingests streams + * + * @generated from enum value: INGRESS = 1; + */ + INGRESS = 1, + + /** + * only consumes streams + * + * @generated from enum value: EGRESS = 2; + */ + EGRESS = 2, + + /** + * SIP participants + * + * @generated from enum value: SIP = 3; + */ + SIP = 3, + + /** + * LiveKit agents + * + * @generated from enum value: AGENT = 4; + */ + AGENT = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(ParticipantInfo_Kind) +proto3.util.setEnumType(ParticipantInfo_Kind, "livekit.ParticipantInfo.Kind", [ + { no: 0, name: "STANDARD" }, + { no: 1, name: "INGRESS" }, + { no: 2, name: "EGRESS" }, + { no: 3, name: "SIP" }, + { no: 4, name: "AGENT" }, +]); + +/** + * @generated from message livekit.Encryption + */ +export class Encryption extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Encryption"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Encryption { + return new Encryption().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Encryption { + return new Encryption().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Encryption { + return new Encryption().fromJsonString(jsonString, options); + } + + static equals(a: Encryption | PlainMessage | undefined, b: Encryption | PlainMessage | undefined): boolean { + return proto3.util.equals(Encryption, a, b); + } +} + +/** + * @generated from enum livekit.Encryption.Type + */ +export enum Encryption_Type { + /** + * @generated from enum value: NONE = 0; + */ + NONE = 0, + + /** + * @generated from enum value: GCM = 1; + */ + GCM = 1, + + /** + * @generated from enum value: CUSTOM = 2; + */ + CUSTOM = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(Encryption_Type) +proto3.util.setEnumType(Encryption_Type, "livekit.Encryption.Type", [ + { no: 0, name: "NONE" }, + { no: 1, name: "GCM" }, + { no: 2, name: "CUSTOM" }, +]); + +/** + * @generated from message livekit.SimulcastCodecInfo + */ +export class SimulcastCodecInfo extends Message { + /** + * @generated from field: string mime_type = 1; + */ + mimeType = ""; + + /** + * @generated from field: string mid = 2; + */ + mid = ""; + + /** + * @generated from field: string cid = 3; + */ + cid = ""; + + /** + * @generated from field: repeated livekit.VideoLayer layers = 4; + */ + layers: VideoLayer[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SimulcastCodecInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "mid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "layers", kind: "message", T: VideoLayer, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SimulcastCodecInfo { + return new SimulcastCodecInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SimulcastCodecInfo { + return new SimulcastCodecInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SimulcastCodecInfo { + return new SimulcastCodecInfo().fromJsonString(jsonString, options); + } + + static equals(a: SimulcastCodecInfo | PlainMessage | undefined, b: SimulcastCodecInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SimulcastCodecInfo, a, b); + } +} + +/** + * @generated from message livekit.TrackInfo + */ +export class TrackInfo extends Message { + /** + * @generated from field: string sid = 1; + */ + sid = ""; + + /** + * @generated from field: livekit.TrackType type = 2; + */ + type = TrackType.AUDIO; + + /** + * @generated from field: string name = 3; + */ + name = ""; + + /** + * @generated from field: bool muted = 4; + */ + muted = false; + + /** + * original width of video (unset for audio) + * clients may receive a lower resolution version with simulcast + * + * @generated from field: uint32 width = 5; + */ + width = 0; + + /** + * original height of video (unset for audio) + * + * @generated from field: uint32 height = 6; + */ + height = 0; + + /** + * true if track is simulcasted + * + * @generated from field: bool simulcast = 7; + */ + simulcast = false; + + /** + * true if DTX (Discontinuous Transmission) is disabled for audio + * + * @generated from field: bool disable_dtx = 8; + */ + disableDtx = false; + + /** + * source of media + * + * @generated from field: livekit.TrackSource source = 9; + */ + source = TrackSource.UNKNOWN; + + /** + * @generated from field: repeated livekit.VideoLayer layers = 10; + */ + layers: VideoLayer[] = []; + + /** + * mime type of codec + * + * @generated from field: string mime_type = 11; + */ + mimeType = ""; + + /** + * @generated from field: string mid = 12; + */ + mid = ""; + + /** + * @generated from field: repeated livekit.SimulcastCodecInfo codecs = 13; + */ + codecs: SimulcastCodecInfo[] = []; + + /** + * @generated from field: bool stereo = 14; + */ + stereo = false; + + /** + * true if RED (Redundant Encoding) is disabled for audio + * + * @generated from field: bool disable_red = 15; + */ + disableRed = false; + + /** + * @generated from field: livekit.Encryption.Type encryption = 16; + */ + encryption = Encryption_Type.NONE; + + /** + * @generated from field: string stream = 17; + */ + stream = ""; + + /** + * @generated from field: livekit.TimedVersion version = 18; + */ + version?: TimedVersion; + + /** + * @generated from field: repeated livekit.AudioTrackFeature audio_features = 19; + */ + audioFeatures: AudioTrackFeature[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "type", kind: "enum", T: proto3.getEnumType(TrackType) }, + { no: 3, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 5, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 6, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 7, name: "simulcast", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 8, name: "disable_dtx", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 9, name: "source", kind: "enum", T: proto3.getEnumType(TrackSource) }, + { no: 10, name: "layers", kind: "message", T: VideoLayer, repeated: true }, + { no: 11, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 12, name: "mid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 13, name: "codecs", kind: "message", T: SimulcastCodecInfo, repeated: true }, + { no: 14, name: "stereo", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 15, name: "disable_red", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 16, name: "encryption", kind: "enum", T: proto3.getEnumType(Encryption_Type) }, + { no: 17, name: "stream", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 18, name: "version", kind: "message", T: TimedVersion }, + { no: 19, name: "audio_features", kind: "enum", T: proto3.getEnumType(AudioTrackFeature), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackInfo { + return new TrackInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackInfo { + return new TrackInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackInfo { + return new TrackInfo().fromJsonString(jsonString, options); + } + + static equals(a: TrackInfo | PlainMessage | undefined, b: TrackInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackInfo, a, b); + } +} + +/** + * provide information about available spatial layers + * + * @generated from message livekit.VideoLayer + */ +export class VideoLayer extends Message { + /** + * for tracks with a single layer, this should be HIGH + * + * @generated from field: livekit.VideoQuality quality = 1; + */ + quality = VideoQuality.LOW; + + /** + * @generated from field: uint32 width = 2; + */ + width = 0; + + /** + * @generated from field: uint32 height = 3; + */ + height = 0; + + /** + * target bitrate in bit per second (bps), server will measure actual + * + * @generated from field: uint32 bitrate = 4; + */ + bitrate = 0; + + /** + * @generated from field: uint32 ssrc = 5; + */ + ssrc = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.VideoLayer"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "quality", kind: "enum", T: proto3.getEnumType(VideoQuality) }, + { no: 2, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "ssrc", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): VideoLayer { + return new VideoLayer().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): VideoLayer { + return new VideoLayer().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): VideoLayer { + return new VideoLayer().fromJsonString(jsonString, options); + } + + static equals(a: VideoLayer | PlainMessage | undefined, b: VideoLayer | PlainMessage | undefined): boolean { + return proto3.util.equals(VideoLayer, a, b); + } +} + +/** + * new DataPacket API + * + * @generated from message livekit.DataPacket + */ +export class DataPacket extends Message { + /** + * @generated from field: livekit.DataPacket.Kind kind = 1 [deprecated = true]; + * @deprecated + */ + kind = DataPacket_Kind.RELIABLE; + + /** + * participant identity of user that sent the message + * + * @generated from field: string participant_identity = 4; + */ + participantIdentity = ""; + + /** + * identities of participants who will receive the message (sent to all by default) + * + * @generated from field: repeated string destination_identities = 5; + */ + destinationIdentities: string[] = []; + + /** + * @generated from oneof livekit.DataPacket.value + */ + value: { + /** + * @generated from field: livekit.UserPacket user = 2; + */ + value: UserPacket; + case: "user"; + } | { + /** + * @generated from field: livekit.ActiveSpeakerUpdate speaker = 3 [deprecated = true]; + * @deprecated + */ + value: ActiveSpeakerUpdate; + case: "speaker"; + } | { + /** + * @generated from field: livekit.SipDTMF sip_dtmf = 6; + */ + value: SipDTMF; + case: "sipDtmf"; + } | { + /** + * @generated from field: livekit.Transcription transcription = 7; + */ + value: Transcription; + case: "transcription"; + } | { + /** + * @generated from field: livekit.MetricsBatch metrics = 8; + */ + value: MetricsBatch; + case: "metrics"; + } | { + /** + * @generated from field: livekit.ChatMessage chat_message = 9; + */ + value: ChatMessage; + case: "chatMessage"; + } | { + /** + * @generated from field: livekit.RpcRequest rpc_request = 10; + */ + value: RpcRequest; + case: "rpcRequest"; + } | { + /** + * @generated from field: livekit.RpcAck rpc_ack = 11; + */ + value: RpcAck; + case: "rpcAck"; + } | { + /** + * @generated from field: livekit.RpcResponse rpc_response = 12; + */ + value: RpcResponse; + case: "rpcResponse"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DataPacket"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "kind", kind: "enum", T: proto3.getEnumType(DataPacket_Kind) }, + { no: 4, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 2, name: "user", kind: "message", T: UserPacket, oneof: "value" }, + { no: 3, name: "speaker", kind: "message", T: ActiveSpeakerUpdate, oneof: "value" }, + { no: 6, name: "sip_dtmf", kind: "message", T: SipDTMF, oneof: "value" }, + { no: 7, name: "transcription", kind: "message", T: Transcription, oneof: "value" }, + { no: 8, name: "metrics", kind: "message", T: MetricsBatch, oneof: "value" }, + { no: 9, name: "chat_message", kind: "message", T: ChatMessage, oneof: "value" }, + { no: 10, name: "rpc_request", kind: "message", T: RpcRequest, oneof: "value" }, + { no: 11, name: "rpc_ack", kind: "message", T: RpcAck, oneof: "value" }, + { no: 12, name: "rpc_response", kind: "message", T: RpcResponse, oneof: "value" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataPacket { + return new DataPacket().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataPacket { + return new DataPacket().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataPacket { + return new DataPacket().fromJsonString(jsonString, options); + } + + static equals(a: DataPacket | PlainMessage | undefined, b: DataPacket | PlainMessage | undefined): boolean { + return proto3.util.equals(DataPacket, a, b); + } +} + +/** + * @generated from enum livekit.DataPacket.Kind + */ +export enum DataPacket_Kind { + /** + * @generated from enum value: RELIABLE = 0; + */ + RELIABLE = 0, + + /** + * @generated from enum value: LOSSY = 1; + */ + LOSSY = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(DataPacket_Kind) +proto3.util.setEnumType(DataPacket_Kind, "livekit.DataPacket.Kind", [ + { no: 0, name: "RELIABLE" }, + { no: 1, name: "LOSSY" }, +]); + +/** + * @generated from message livekit.ActiveSpeakerUpdate + */ +export class ActiveSpeakerUpdate extends Message { + /** + * @generated from field: repeated livekit.SpeakerInfo speakers = 1; + */ + speakers: SpeakerInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ActiveSpeakerUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "speakers", kind: "message", T: SpeakerInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ActiveSpeakerUpdate { + return new ActiveSpeakerUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ActiveSpeakerUpdate { + return new ActiveSpeakerUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ActiveSpeakerUpdate { + return new ActiveSpeakerUpdate().fromJsonString(jsonString, options); + } + + static equals(a: ActiveSpeakerUpdate | PlainMessage | undefined, b: ActiveSpeakerUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(ActiveSpeakerUpdate, a, b); + } +} + +/** + * @generated from message livekit.SpeakerInfo + */ +export class SpeakerInfo extends Message { + /** + * @generated from field: string sid = 1; + */ + sid = ""; + + /** + * audio level, 0-1.0, 1 is loudest + * + * @generated from field: float level = 2; + */ + level = 0; + + /** + * true if speaker is currently active + * + * @generated from field: bool active = 3; + */ + active = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SpeakerInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "level", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 3, name: "active", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SpeakerInfo { + return new SpeakerInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SpeakerInfo { + return new SpeakerInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SpeakerInfo { + return new SpeakerInfo().fromJsonString(jsonString, options); + } + + static equals(a: SpeakerInfo | PlainMessage | undefined, b: SpeakerInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SpeakerInfo, a, b); + } +} + +/** + * @generated from message livekit.UserPacket + */ +export class UserPacket extends Message { + /** + * participant ID of user that sent the message + * + * @generated from field: string participant_sid = 1 [deprecated = true]; + * @deprecated + */ + participantSid = ""; + + /** + * @generated from field: string participant_identity = 5 [deprecated = true]; + * @deprecated + */ + participantIdentity = ""; + + /** + * user defined payload + * + * @generated from field: bytes payload = 2; + */ + payload = new Uint8Array(0); + + /** + * the ID of the participants who will receive the message (sent to all by default) + * + * @generated from field: repeated string destination_sids = 3 [deprecated = true]; + * @deprecated + */ + destinationSids: string[] = []; + + /** + * identities of participants who will receive the message (sent to all by default) + * + * @generated from field: repeated string destination_identities = 6 [deprecated = true]; + * @deprecated + */ + destinationIdentities: string[] = []; + + /** + * topic under which the message was published + * + * @generated from field: optional string topic = 4; + */ + topic?: string; + + /** + * Unique ID to indentify the message + * + * @generated from field: optional string id = 8; + */ + id?: string; + + /** + * start and end time allow relating the message to specific media time + * + * @generated from field: optional uint64 start_time = 9; + */ + startTime?: bigint; + + /** + * @generated from field: optional uint64 end_time = 10; + */ + endTime?: bigint; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UserPacket"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "payload", kind: "scalar", T: 12 /* ScalarType.BYTES */ }, + { no: 3, name: "destination_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 6, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "topic", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 8, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 9, name: "start_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 10, name: "end_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UserPacket { + return new UserPacket().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UserPacket { + return new UserPacket().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UserPacket { + return new UserPacket().fromJsonString(jsonString, options); + } + + static equals(a: UserPacket | PlainMessage | undefined, b: UserPacket | PlainMessage | undefined): boolean { + return proto3.util.equals(UserPacket, a, b); + } +} + +/** + * @generated from message livekit.SipDTMF + */ +export class SipDTMF extends Message { + /** + * @generated from field: uint32 code = 3; + */ + code = 0; + + /** + * @generated from field: string digit = 4; + */ + digit = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SipDTMF"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 3, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "digit", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SipDTMF { + return new SipDTMF().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SipDTMF { + return new SipDTMF().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SipDTMF { + return new SipDTMF().fromJsonString(jsonString, options); + } + + static equals(a: SipDTMF | PlainMessage | undefined, b: SipDTMF | PlainMessage | undefined): boolean { + return proto3.util.equals(SipDTMF, a, b); + } +} + +/** + * @generated from message livekit.Transcription + */ +export class Transcription extends Message { + /** + * Participant that got its speech transcribed + * + * @generated from field: string transcribed_participant_identity = 2; + */ + transcribedParticipantIdentity = ""; + + /** + * @generated from field: string track_id = 3; + */ + trackId = ""; + + /** + * @generated from field: repeated livekit.TranscriptionSegment segments = 4; + */ + segments: TranscriptionSegment[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Transcription"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 2, name: "transcribed_participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "track_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "segments", kind: "message", T: TranscriptionSegment, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Transcription { + return new Transcription().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Transcription { + return new Transcription().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Transcription { + return new Transcription().fromJsonString(jsonString, options); + } + + static equals(a: Transcription | PlainMessage | undefined, b: Transcription | PlainMessage | undefined): boolean { + return proto3.util.equals(Transcription, a, b); + } +} + +/** + * @generated from message livekit.TranscriptionSegment + */ +export class TranscriptionSegment extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string text = 2; + */ + text = ""; + + /** + * @generated from field: uint64 start_time = 3; + */ + startTime = protoInt64.zero; + + /** + * @generated from field: uint64 end_time = 4; + */ + endTime = protoInt64.zero; + + /** + * @generated from field: bool final = 5; + */ + final = false; + + /** + * @generated from field: string language = 6; + */ + language = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TranscriptionSegment"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "start_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 4, name: "end_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 5, name: "final", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TranscriptionSegment { + return new TranscriptionSegment().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TranscriptionSegment { + return new TranscriptionSegment().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TranscriptionSegment { + return new TranscriptionSegment().fromJsonString(jsonString, options); + } + + static equals(a: TranscriptionSegment | PlainMessage | undefined, b: TranscriptionSegment | PlainMessage | undefined): boolean { + return proto3.util.equals(TranscriptionSegment, a, b); + } +} + +/** + * @generated from message livekit.ChatMessage + */ +export class ChatMessage extends Message { + /** + * uuid + * + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: int64 timestamp = 2; + */ + timestamp = protoInt64.zero; + + /** + * populated only if the intent is to edit/update an existing message + * + * @generated from field: optional int64 edit_timestamp = 3; + */ + editTimestamp?: bigint; + + /** + * @generated from field: string message = 4; + */ + message = ""; + + /** + * true to remove message + * + * @generated from field: bool deleted = 5; + */ + deleted = false; + + /** + * true if the chat message has been generated by an agent from a participant's audio transcription + * + * @generated from field: bool generated = 6; + */ + generated = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ChatMessage"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 3, name: "edit_timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true }, + { no: 4, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "deleted", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "generated", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ChatMessage { + return new ChatMessage().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ChatMessage { + return new ChatMessage().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ChatMessage { + return new ChatMessage().fromJsonString(jsonString, options); + } + + static equals(a: ChatMessage | PlainMessage | undefined, b: ChatMessage | PlainMessage | undefined): boolean { + return proto3.util.equals(ChatMessage, a, b); + } +} + +/** + * @generated from message livekit.RpcRequest + */ +export class RpcRequest extends Message { + /** + * @generated from field: string id = 1; + */ + id = ""; + + /** + * @generated from field: string method = 2; + */ + method = ""; + + /** + * @generated from field: string payload = 3; + */ + payload = ""; + + /** + * @generated from field: uint32 response_timeout_ms = 4; + */ + responseTimeoutMs = 0; + + /** + * @generated from field: uint32 version = 5; + */ + version = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RpcRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "method", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "payload", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "response_timeout_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "version", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RpcRequest { + return new RpcRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RpcRequest { + return new RpcRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RpcRequest { + return new RpcRequest().fromJsonString(jsonString, options); + } + + static equals(a: RpcRequest | PlainMessage | undefined, b: RpcRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(RpcRequest, a, b); + } +} + +/** + * @generated from message livekit.RpcAck + */ +export class RpcAck extends Message { + /** + * @generated from field: string request_id = 1; + */ + requestId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RpcAck"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RpcAck { + return new RpcAck().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RpcAck { + return new RpcAck().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RpcAck { + return new RpcAck().fromJsonString(jsonString, options); + } + + static equals(a: RpcAck | PlainMessage | undefined, b: RpcAck | PlainMessage | undefined): boolean { + return proto3.util.equals(RpcAck, a, b); + } +} + +/** + * @generated from message livekit.RpcResponse + */ +export class RpcResponse extends Message { + /** + * @generated from field: string request_id = 1; + */ + requestId = ""; + + /** + * @generated from oneof livekit.RpcResponse.value + */ + value: { + /** + * @generated from field: string payload = 2; + */ + value: string; + case: "payload"; + } | { + /** + * @generated from field: livekit.RpcError error = 3; + */ + value: RpcError; + case: "error"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RpcResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "payload", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "value" }, + { no: 3, name: "error", kind: "message", T: RpcError, oneof: "value" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RpcResponse { + return new RpcResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RpcResponse { + return new RpcResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RpcResponse { + return new RpcResponse().fromJsonString(jsonString, options); + } + + static equals(a: RpcResponse | PlainMessage | undefined, b: RpcResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(RpcResponse, a, b); + } +} + +/** + * @generated from message livekit.RpcError + */ +export class RpcError extends Message { + /** + * @generated from field: uint32 code = 1; + */ + code = 0; + + /** + * @generated from field: string message = 2; + */ + message = ""; + + /** + * @generated from field: string data = 3; + */ + data = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RpcError"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "data", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RpcError { + return new RpcError().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RpcError { + return new RpcError().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RpcError { + return new RpcError().fromJsonString(jsonString, options); + } + + static equals(a: RpcError | PlainMessage | undefined, b: RpcError | PlainMessage | undefined): boolean { + return proto3.util.equals(RpcError, a, b); + } +} + +/** + * @generated from message livekit.ParticipantTracks + */ +export class ParticipantTracks extends Message { + /** + * participant ID of participant to whom the tracks belong + * + * @generated from field: string participant_sid = 1; + */ + participantSid = ""; + + /** + * @generated from field: repeated string track_sids = 2; + */ + trackSids: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ParticipantTracks"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ParticipantTracks { + return new ParticipantTracks().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ParticipantTracks { + return new ParticipantTracks().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ParticipantTracks { + return new ParticipantTracks().fromJsonString(jsonString, options); + } + + static equals(a: ParticipantTracks | PlainMessage | undefined, b: ParticipantTracks | PlainMessage | undefined): boolean { + return proto3.util.equals(ParticipantTracks, a, b); + } +} + +/** + * details about the server + * + * @generated from message livekit.ServerInfo + */ +export class ServerInfo extends Message { + /** + * @generated from field: livekit.ServerInfo.Edition edition = 1; + */ + edition = ServerInfo_Edition.Standard; + + /** + * @generated from field: string version = 2; + */ + version = ""; + + /** + * @generated from field: int32 protocol = 3; + */ + protocol = 0; + + /** + * @generated from field: string region = 4; + */ + region = ""; + + /** + * @generated from field: string node_id = 5; + */ + nodeId = ""; + + /** + * additional debugging information. sent only if server is in development mode + * + * @generated from field: string debug_info = 6; + */ + debugInfo = ""; + + /** + * @generated from field: int32 agent_protocol = 7; + */ + agentProtocol = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ServerInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "edition", kind: "enum", T: proto3.getEnumType(ServerInfo_Edition) }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "protocol", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "debug_info", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "agent_protocol", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ServerInfo { + return new ServerInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ServerInfo { + return new ServerInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ServerInfo { + return new ServerInfo().fromJsonString(jsonString, options); + } + + static equals(a: ServerInfo | PlainMessage | undefined, b: ServerInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(ServerInfo, a, b); + } +} + +/** + * @generated from enum livekit.ServerInfo.Edition + */ +export enum ServerInfo_Edition { + /** + * @generated from enum value: Standard = 0; + */ + Standard = 0, + + /** + * @generated from enum value: Cloud = 1; + */ + Cloud = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(ServerInfo_Edition) +proto3.util.setEnumType(ServerInfo_Edition, "livekit.ServerInfo.Edition", [ + { no: 0, name: "Standard" }, + { no: 1, name: "Cloud" }, +]); + +/** + * details about the client + * + * @generated from message livekit.ClientInfo + */ +export class ClientInfo extends Message { + /** + * @generated from field: livekit.ClientInfo.SDK sdk = 1; + */ + sdk = ClientInfo_SDK.UNKNOWN; + + /** + * @generated from field: string version = 2; + */ + version = ""; + + /** + * @generated from field: int32 protocol = 3; + */ + protocol = 0; + + /** + * @generated from field: string os = 4; + */ + os = ""; + + /** + * @generated from field: string os_version = 5; + */ + osVersion = ""; + + /** + * @generated from field: string device_model = 6; + */ + deviceModel = ""; + + /** + * @generated from field: string browser = 7; + */ + browser = ""; + + /** + * @generated from field: string browser_version = 8; + */ + browserVersion = ""; + + /** + * @generated from field: string address = 9; + */ + address = ""; + + /** + * wifi, wired, cellular, vpn, empty if not known + * + * @generated from field: string network = 10; + */ + network = ""; + + /** + * comma separated list of additional LiveKit SDKs in use of this client, with versions + * e.g. "components-js:1.2.3,track-processors-js:1.2.3" + * + * @generated from field: string other_sdks = 11; + */ + otherSdks = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ClientInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sdk", kind: "enum", T: proto3.getEnumType(ClientInfo_SDK) }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "protocol", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 4, name: "os", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "os_version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "device_model", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "browser", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "browser_version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "network", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "other_sdks", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ClientInfo { + return new ClientInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ClientInfo { + return new ClientInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ClientInfo { + return new ClientInfo().fromJsonString(jsonString, options); + } + + static equals(a: ClientInfo | PlainMessage | undefined, b: ClientInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(ClientInfo, a, b); + } +} + +/** + * @generated from enum livekit.ClientInfo.SDK + */ +export enum ClientInfo_SDK { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: JS = 1; + */ + JS = 1, + + /** + * @generated from enum value: SWIFT = 2; + */ + SWIFT = 2, + + /** + * @generated from enum value: ANDROID = 3; + */ + ANDROID = 3, + + /** + * @generated from enum value: FLUTTER = 4; + */ + FLUTTER = 4, + + /** + * @generated from enum value: GO = 5; + */ + GO = 5, + + /** + * @generated from enum value: UNITY = 6; + */ + UNITY = 6, + + /** + * @generated from enum value: REACT_NATIVE = 7; + */ + REACT_NATIVE = 7, + + /** + * @generated from enum value: RUST = 8; + */ + RUST = 8, + + /** + * @generated from enum value: PYTHON = 9; + */ + PYTHON = 9, + + /** + * @generated from enum value: CPP = 10; + */ + CPP = 10, + + /** + * @generated from enum value: UNITY_WEB = 11; + */ + UNITY_WEB = 11, + + /** + * @generated from enum value: NODE = 12; + */ + NODE = 12, +} +// Retrieve enum metadata with: proto3.getEnumType(ClientInfo_SDK) +proto3.util.setEnumType(ClientInfo_SDK, "livekit.ClientInfo.SDK", [ + { no: 0, name: "UNKNOWN" }, + { no: 1, name: "JS" }, + { no: 2, name: "SWIFT" }, + { no: 3, name: "ANDROID" }, + { no: 4, name: "FLUTTER" }, + { no: 5, name: "GO" }, + { no: 6, name: "UNITY" }, + { no: 7, name: "REACT_NATIVE" }, + { no: 8, name: "RUST" }, + { no: 9, name: "PYTHON" }, + { no: 10, name: "CPP" }, + { no: 11, name: "UNITY_WEB" }, + { no: 12, name: "NODE" }, +]); + +/** + * server provided client configuration + * + * @generated from message livekit.ClientConfiguration + */ +export class ClientConfiguration extends Message { + /** + * @generated from field: livekit.VideoConfiguration video = 1; + */ + video?: VideoConfiguration; + + /** + * @generated from field: livekit.VideoConfiguration screen = 2; + */ + screen?: VideoConfiguration; + + /** + * @generated from field: livekit.ClientConfigSetting resume_connection = 3; + */ + resumeConnection = ClientConfigSetting.UNSET; + + /** + * @generated from field: livekit.DisabledCodecs disabled_codecs = 4; + */ + disabledCodecs?: DisabledCodecs; + + /** + * @generated from field: livekit.ClientConfigSetting force_relay = 5; + */ + forceRelay = ClientConfigSetting.UNSET; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ClientConfiguration"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "video", kind: "message", T: VideoConfiguration }, + { no: 2, name: "screen", kind: "message", T: VideoConfiguration }, + { no: 3, name: "resume_connection", kind: "enum", T: proto3.getEnumType(ClientConfigSetting) }, + { no: 4, name: "disabled_codecs", kind: "message", T: DisabledCodecs }, + { no: 5, name: "force_relay", kind: "enum", T: proto3.getEnumType(ClientConfigSetting) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ClientConfiguration { + return new ClientConfiguration().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ClientConfiguration { + return new ClientConfiguration().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ClientConfiguration { + return new ClientConfiguration().fromJsonString(jsonString, options); + } + + static equals(a: ClientConfiguration | PlainMessage | undefined, b: ClientConfiguration | PlainMessage | undefined): boolean { + return proto3.util.equals(ClientConfiguration, a, b); + } +} + +/** + * @generated from message livekit.VideoConfiguration + */ +export class VideoConfiguration extends Message { + /** + * @generated from field: livekit.ClientConfigSetting hardware_encoder = 1; + */ + hardwareEncoder = ClientConfigSetting.UNSET; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.VideoConfiguration"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "hardware_encoder", kind: "enum", T: proto3.getEnumType(ClientConfigSetting) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): VideoConfiguration { + return new VideoConfiguration().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): VideoConfiguration { + return new VideoConfiguration().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): VideoConfiguration { + return new VideoConfiguration().fromJsonString(jsonString, options); + } + + static equals(a: VideoConfiguration | PlainMessage | undefined, b: VideoConfiguration | PlainMessage | undefined): boolean { + return proto3.util.equals(VideoConfiguration, a, b); + } +} + +/** + * @generated from message livekit.DisabledCodecs + */ +export class DisabledCodecs extends Message { + /** + * disabled for both publish and subscribe + * + * @generated from field: repeated livekit.Codec codecs = 1; + */ + codecs: Codec[] = []; + + /** + * only disable for publish + * + * @generated from field: repeated livekit.Codec publish = 2; + */ + publish: Codec[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DisabledCodecs"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "codecs", kind: "message", T: Codec, repeated: true }, + { no: 2, name: "publish", kind: "message", T: Codec, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DisabledCodecs { + return new DisabledCodecs().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DisabledCodecs { + return new DisabledCodecs().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DisabledCodecs { + return new DisabledCodecs().fromJsonString(jsonString, options); + } + + static equals(a: DisabledCodecs | PlainMessage | undefined, b: DisabledCodecs | PlainMessage | undefined): boolean { + return proto3.util.equals(DisabledCodecs, a, b); + } +} + +/** + * @generated from message livekit.RTPDrift + */ +export class RTPDrift extends Message { + /** + * @generated from field: google.protobuf.Timestamp start_time = 1; + */ + startTime?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp end_time = 2; + */ + endTime?: Timestamp; + + /** + * @generated from field: double duration = 3; + */ + duration = 0; + + /** + * @generated from field: uint64 start_timestamp = 4; + */ + startTimestamp = protoInt64.zero; + + /** + * @generated from field: uint64 end_timestamp = 5; + */ + endTimestamp = protoInt64.zero; + + /** + * @generated from field: uint64 rtp_clock_ticks = 6; + */ + rtpClockTicks = protoInt64.zero; + + /** + * @generated from field: int64 drift_samples = 7; + */ + driftSamples = protoInt64.zero; + + /** + * @generated from field: double drift_ms = 8; + */ + driftMs = 0; + + /** + * @generated from field: double clock_rate = 9; + */ + clockRate = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RTPDrift"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "start_time", kind: "message", T: Timestamp }, + { no: 2, name: "end_time", kind: "message", T: Timestamp }, + { no: 3, name: "duration", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 4, name: "start_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 5, name: "end_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 6, name: "rtp_clock_ticks", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 7, name: "drift_samples", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 8, name: "drift_ms", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 9, name: "clock_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RTPDrift { + return new RTPDrift().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RTPDrift { + return new RTPDrift().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RTPDrift { + return new RTPDrift().fromJsonString(jsonString, options); + } + + static equals(a: RTPDrift | PlainMessage | undefined, b: RTPDrift | PlainMessage | undefined): boolean { + return proto3.util.equals(RTPDrift, a, b); + } +} + +/** + * @generated from message livekit.RTPStats + */ +export class RTPStats extends Message { + /** + * @generated from field: google.protobuf.Timestamp start_time = 1; + */ + startTime?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp end_time = 2; + */ + endTime?: Timestamp; + + /** + * @generated from field: double duration = 3; + */ + duration = 0; + + /** + * @generated from field: uint32 packets = 4; + */ + packets = 0; + + /** + * @generated from field: double packet_rate = 5; + */ + packetRate = 0; + + /** + * @generated from field: uint64 bytes = 6; + */ + bytes = protoInt64.zero; + + /** + * @generated from field: uint64 header_bytes = 39; + */ + headerBytes = protoInt64.zero; + + /** + * @generated from field: double bitrate = 7; + */ + bitrate = 0; + + /** + * @generated from field: uint32 packets_lost = 8; + */ + packetsLost = 0; + + /** + * @generated from field: double packet_loss_rate = 9; + */ + packetLossRate = 0; + + /** + * @generated from field: float packet_loss_percentage = 10; + */ + packetLossPercentage = 0; + + /** + * @generated from field: uint32 packets_duplicate = 11; + */ + packetsDuplicate = 0; + + /** + * @generated from field: double packet_duplicate_rate = 12; + */ + packetDuplicateRate = 0; + + /** + * @generated from field: uint64 bytes_duplicate = 13; + */ + bytesDuplicate = protoInt64.zero; + + /** + * @generated from field: uint64 header_bytes_duplicate = 40; + */ + headerBytesDuplicate = protoInt64.zero; + + /** + * @generated from field: double bitrate_duplicate = 14; + */ + bitrateDuplicate = 0; + + /** + * @generated from field: uint32 packets_padding = 15; + */ + packetsPadding = 0; + + /** + * @generated from field: double packet_padding_rate = 16; + */ + packetPaddingRate = 0; + + /** + * @generated from field: uint64 bytes_padding = 17; + */ + bytesPadding = protoInt64.zero; + + /** + * @generated from field: uint64 header_bytes_padding = 41; + */ + headerBytesPadding = protoInt64.zero; + + /** + * @generated from field: double bitrate_padding = 18; + */ + bitratePadding = 0; + + /** + * @generated from field: uint32 packets_out_of_order = 19; + */ + packetsOutOfOrder = 0; + + /** + * @generated from field: uint32 frames = 20; + */ + frames = 0; + + /** + * @generated from field: double frame_rate = 21; + */ + frameRate = 0; + + /** + * @generated from field: double jitter_current = 22; + */ + jitterCurrent = 0; + + /** + * @generated from field: double jitter_max = 23; + */ + jitterMax = 0; + + /** + * @generated from field: map gap_histogram = 24; + */ + gapHistogram: { [key: number]: number } = {}; + + /** + * @generated from field: uint32 nacks = 25; + */ + nacks = 0; + + /** + * @generated from field: uint32 nack_acks = 37; + */ + nackAcks = 0; + + /** + * @generated from field: uint32 nack_misses = 26; + */ + nackMisses = 0; + + /** + * @generated from field: uint32 nack_repeated = 38; + */ + nackRepeated = 0; + + /** + * @generated from field: uint32 plis = 27; + */ + plis = 0; + + /** + * @generated from field: google.protobuf.Timestamp last_pli = 28; + */ + lastPli?: Timestamp; + + /** + * @generated from field: uint32 firs = 29; + */ + firs = 0; + + /** + * @generated from field: google.protobuf.Timestamp last_fir = 30; + */ + lastFir?: Timestamp; + + /** + * @generated from field: uint32 rtt_current = 31; + */ + rttCurrent = 0; + + /** + * @generated from field: uint32 rtt_max = 32; + */ + rttMax = 0; + + /** + * @generated from field: uint32 key_frames = 33; + */ + keyFrames = 0; + + /** + * @generated from field: google.protobuf.Timestamp last_key_frame = 34; + */ + lastKeyFrame?: Timestamp; + + /** + * @generated from field: uint32 layer_lock_plis = 35; + */ + layerLockPlis = 0; + + /** + * @generated from field: google.protobuf.Timestamp last_layer_lock_pli = 36; + */ + lastLayerLockPli?: Timestamp; + + /** + * @generated from field: livekit.RTPDrift packet_drift = 44; + */ + packetDrift?: RTPDrift; + + /** + * @generated from field: livekit.RTPDrift ntp_report_drift = 45; + */ + ntpReportDrift?: RTPDrift; + + /** + * @generated from field: livekit.RTPDrift rebased_report_drift = 46; + */ + rebasedReportDrift?: RTPDrift; + + /** + * NEXT_ID: 48 + * + * @generated from field: livekit.RTPDrift received_report_drift = 47; + */ + receivedReportDrift?: RTPDrift; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RTPStats"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "start_time", kind: "message", T: Timestamp }, + { no: 2, name: "end_time", kind: "message", T: Timestamp }, + { no: 3, name: "duration", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 4, name: "packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "packet_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 6, name: "bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 39, name: "header_bytes", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 7, name: "bitrate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 8, name: "packets_lost", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 9, name: "packet_loss_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 10, name: "packet_loss_percentage", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + { no: 11, name: "packets_duplicate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 12, name: "packet_duplicate_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 13, name: "bytes_duplicate", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 40, name: "header_bytes_duplicate", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 14, name: "bitrate_duplicate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 15, name: "packets_padding", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 16, name: "packet_padding_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 17, name: "bytes_padding", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 41, name: "header_bytes_padding", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 18, name: "bitrate_padding", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 19, name: "packets_out_of_order", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 20, name: "frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 21, name: "frame_rate", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 22, name: "jitter_current", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 23, name: "jitter_max", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ }, + { no: 24, name: "gap_histogram", kind: "map", K: 5 /* ScalarType.INT32 */, V: {kind: "scalar", T: 13 /* ScalarType.UINT32 */} }, + { no: 25, name: "nacks", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 37, name: "nack_acks", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 26, name: "nack_misses", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 38, name: "nack_repeated", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 27, name: "plis", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 28, name: "last_pli", kind: "message", T: Timestamp }, + { no: 29, name: "firs", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 30, name: "last_fir", kind: "message", T: Timestamp }, + { no: 31, name: "rtt_current", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 32, name: "rtt_max", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 33, name: "key_frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 34, name: "last_key_frame", kind: "message", T: Timestamp }, + { no: 35, name: "layer_lock_plis", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 36, name: "last_layer_lock_pli", kind: "message", T: Timestamp }, + { no: 44, name: "packet_drift", kind: "message", T: RTPDrift }, + { no: 45, name: "ntp_report_drift", kind: "message", T: RTPDrift }, + { no: 46, name: "rebased_report_drift", kind: "message", T: RTPDrift }, + { no: 47, name: "received_report_drift", kind: "message", T: RTPDrift }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RTPStats { + return new RTPStats().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RTPStats { + return new RTPStats().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RTPStats { + return new RTPStats().fromJsonString(jsonString, options); + } + + static equals(a: RTPStats | PlainMessage | undefined, b: RTPStats | PlainMessage | undefined): boolean { + return proto3.util.equals(RTPStats, a, b); + } +} + +/** + * @generated from message livekit.RTCPSenderReportState + */ +export class RTCPSenderReportState extends Message { + /** + * @generated from field: uint32 rtp_timestamp = 1; + */ + rtpTimestamp = 0; + + /** + * @generated from field: uint64 rtp_timestamp_ext = 2; + */ + rtpTimestampExt = protoInt64.zero; + + /** + * @generated from field: uint64 ntp_timestamp = 3; + */ + ntpTimestamp = protoInt64.zero; + + /** + * time at which this happened + * + * @generated from field: int64 at = 4; + */ + at = protoInt64.zero; + + /** + * @generated from field: int64 at_adjusted = 5; + */ + atAdjusted = protoInt64.zero; + + /** + * @generated from field: uint32 packets = 6; + */ + packets = 0; + + /** + * @generated from field: uint64 octets = 7; + */ + octets = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RTCPSenderReportState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "rtp_timestamp", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "rtp_timestamp_ext", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 3, name: "ntp_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 4, name: "at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 5, name: "at_adjusted", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 6, name: "packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 7, name: "octets", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RTCPSenderReportState { + return new RTCPSenderReportState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RTCPSenderReportState { + return new RTCPSenderReportState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RTCPSenderReportState { + return new RTCPSenderReportState().fromJsonString(jsonString, options); + } + + static equals(a: RTCPSenderReportState | PlainMessage | undefined, b: RTCPSenderReportState | PlainMessage | undefined): boolean { + return proto3.util.equals(RTCPSenderReportState, a, b); + } +} + +/** + * @generated from message livekit.RTPForwarderState + */ +export class RTPForwarderState extends Message { + /** + * @generated from field: bool started = 1; + */ + started = false; + + /** + * @generated from field: int32 reference_layer_spatial = 2; + */ + referenceLayerSpatial = 0; + + /** + * @generated from field: int64 pre_start_time = 3; + */ + preStartTime = protoInt64.zero; + + /** + * @generated from field: uint64 ext_first_timestamp = 4; + */ + extFirstTimestamp = protoInt64.zero; + + /** + * @generated from field: uint64 dummy_start_timestamp_offset = 5; + */ + dummyStartTimestampOffset = protoInt64.zero; + + /** + * @generated from field: livekit.RTPMungerState rtp_munger = 6; + */ + rtpMunger?: RTPMungerState; + + /** + * @generated from oneof livekit.RTPForwarderState.codec_munger + */ + codecMunger: { + /** + * @generated from field: livekit.VP8MungerState vp8_munger = 7; + */ + value: VP8MungerState; + case: "vp8Munger"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + /** + * @generated from field: repeated livekit.RTCPSenderReportState sender_report_state = 8; + */ + senderReportState: RTCPSenderReportState[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RTPForwarderState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "started", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "reference_layer_spatial", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 3, name: "pre_start_time", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 4, name: "ext_first_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 5, name: "dummy_start_timestamp_offset", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 6, name: "rtp_munger", kind: "message", T: RTPMungerState }, + { no: 7, name: "vp8_munger", kind: "message", T: VP8MungerState, oneof: "codec_munger" }, + { no: 8, name: "sender_report_state", kind: "message", T: RTCPSenderReportState, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RTPForwarderState { + return new RTPForwarderState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RTPForwarderState { + return new RTPForwarderState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RTPForwarderState { + return new RTPForwarderState().fromJsonString(jsonString, options); + } + + static equals(a: RTPForwarderState | PlainMessage | undefined, b: RTPForwarderState | PlainMessage | undefined): boolean { + return proto3.util.equals(RTPForwarderState, a, b); + } +} + +/** + * @generated from message livekit.RTPMungerState + */ +export class RTPMungerState extends Message { + /** + * @generated from field: uint64 ext_last_sequence_number = 1; + */ + extLastSequenceNumber = protoInt64.zero; + + /** + * @generated from field: uint64 ext_second_last_sequence_number = 2; + */ + extSecondLastSequenceNumber = protoInt64.zero; + + /** + * @generated from field: uint64 ext_last_timestamp = 3; + */ + extLastTimestamp = protoInt64.zero; + + /** + * @generated from field: uint64 ext_second_last_timestamp = 4; + */ + extSecondLastTimestamp = protoInt64.zero; + + /** + * @generated from field: bool last_marker = 5; + */ + lastMarker = false; + + /** + * @generated from field: bool second_last_marker = 6; + */ + secondLastMarker = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RTPMungerState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ext_last_sequence_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 2, name: "ext_second_last_sequence_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 3, name: "ext_last_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 4, name: "ext_second_last_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ }, + { no: 5, name: "last_marker", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "second_last_marker", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RTPMungerState { + return new RTPMungerState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RTPMungerState { + return new RTPMungerState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RTPMungerState { + return new RTPMungerState().fromJsonString(jsonString, options); + } + + static equals(a: RTPMungerState | PlainMessage | undefined, b: RTPMungerState | PlainMessage | undefined): boolean { + return proto3.util.equals(RTPMungerState, a, b); + } +} + +/** + * @generated from message livekit.VP8MungerState + */ +export class VP8MungerState extends Message { + /** + * @generated from field: int32 ext_last_picture_id = 1; + */ + extLastPictureId = 0; + + /** + * @generated from field: bool picture_id_used = 2; + */ + pictureIdUsed = false; + + /** + * @generated from field: uint32 last_tl0_pic_idx = 3; + */ + lastTl0PicIdx = 0; + + /** + * @generated from field: bool tl0_pic_idx_used = 4; + */ + tl0PicIdxUsed = false; + + /** + * @generated from field: bool tid_used = 5; + */ + tidUsed = false; + + /** + * @generated from field: uint32 last_key_idx = 6; + */ + lastKeyIdx = 0; + + /** + * @generated from field: bool key_idx_used = 7; + */ + keyIdxUsed = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.VP8MungerState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ext_last_picture_id", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 2, name: "picture_id_used", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "last_tl0_pic_idx", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "tl0_pic_idx_used", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 5, name: "tid_used", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "last_key_idx", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 7, name: "key_idx_used", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): VP8MungerState { + return new VP8MungerState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): VP8MungerState { + return new VP8MungerState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): VP8MungerState { + return new VP8MungerState().fromJsonString(jsonString, options); + } + + static equals(a: VP8MungerState | PlainMessage | undefined, b: VP8MungerState | PlainMessage | undefined): boolean { + return proto3.util.equals(VP8MungerState, a, b); + } +} + +/** + * @generated from message livekit.TimedVersion + */ +export class TimedVersion extends Message { + /** + * @generated from field: int64 unix_micro = 1; + */ + unixMicro = protoInt64.zero; + + /** + * @generated from field: int32 ticks = 2; + */ + ticks = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TimedVersion"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "unix_micro", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "ticks", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TimedVersion { + return new TimedVersion().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TimedVersion { + return new TimedVersion().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TimedVersion { + return new TimedVersion().fromJsonString(jsonString, options); + } + + static equals(a: TimedVersion | PlainMessage | undefined, b: TimedVersion | PlainMessage | undefined): boolean { + return proto3.util.equals(TimedVersion, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_room_pb.ts b/packages/javascript/src/gen/livekit_room_pb.ts new file mode 100644 index 00000000..daca64ef --- /dev/null +++ b/packages/javascript/src/gen/livekit_room_pb.ts @@ -0,0 +1,1071 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_room.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; +import { RoomAgentDispatch } from "./livekit_agent_dispatch_pb.js"; +import { AutoParticipantEgress, AutoTrackEgress, RoomCompositeEgressRequest } from "./livekit_egress_pb.js"; +import { DataPacket_Kind, ParticipantInfo, ParticipantPermission, ParticipantTracks, Room, TrackInfo } from "./livekit_models_pb.js"; + +/** + * @generated from message livekit.CreateRoomRequest + */ +export class CreateRoomRequest extends Message { + /** + * name of the room + * + * @generated from field: string name = 1; + */ + name = ""; + + /** + * configuration to use for this room parameters. Setting parameters below override the config defaults. + * + * @generated from field: string room_preset = 12; + */ + roomPreset = ""; + + /** + * number of seconds to keep the room open if no one joins + * + * @generated from field: uint32 empty_timeout = 2; + */ + emptyTimeout = 0; + + /** + * number of seconds to keep the room open after everyone leaves + * + * @generated from field: uint32 departure_timeout = 10; + */ + departureTimeout = 0; + + /** + * limit number of participants that can be in a room + * + * @generated from field: uint32 max_participants = 3; + */ + maxParticipants = 0; + + /** + * override the node room is allocated to, for debugging + * + * @generated from field: string node_id = 4; + */ + nodeId = ""; + + /** + * metadata of room + * + * @generated from field: string metadata = 5; + */ + metadata = ""; + + /** + * auto-egress configurations + * + * @generated from field: livekit.RoomEgress egress = 6; + */ + egress?: RoomEgress; + + /** + * playout delay of subscriber + * + * @generated from field: uint32 min_playout_delay = 7; + */ + minPlayoutDelay = 0; + + /** + * @generated from field: uint32 max_playout_delay = 8; + */ + maxPlayoutDelay = 0; + + /** + * improves A/V sync when playout_delay set to a value larger than 200ms. It will disables transceiver re-use + * so not recommended for rooms with frequent subscription changes + * + * @generated from field: bool sync_streams = 9; + */ + syncStreams = false; + + /** + * replay + * + * @generated from field: bool replay_enabled = 13; + */ + replayEnabled = false; + + /** + * Define agents that should be dispatched to this room + * + * NEXT-ID: 15 + * + * @generated from field: repeated livekit.RoomAgentDispatch agents = 14; + */ + agents: RoomAgentDispatch[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateRoomRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 12, name: "room_preset", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "empty_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 10, name: "departure_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "max_participants", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "egress", kind: "message", T: RoomEgress }, + { no: 7, name: "min_playout_delay", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 8, name: "max_playout_delay", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 9, name: "sync_streams", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 13, name: "replay_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 14, name: "agents", kind: "message", T: RoomAgentDispatch, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateRoomRequest { + return new CreateRoomRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateRoomRequest { + return new CreateRoomRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateRoomRequest { + return new CreateRoomRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateRoomRequest | PlainMessage | undefined, b: CreateRoomRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateRoomRequest, a, b); + } +} + +/** + * @generated from message livekit.RoomEgress + */ +export class RoomEgress extends Message { + /** + * @generated from field: livekit.RoomCompositeEgressRequest room = 1; + */ + room?: RoomCompositeEgressRequest; + + /** + * @generated from field: livekit.AutoParticipantEgress participant = 3; + */ + participant?: AutoParticipantEgress; + + /** + * @generated from field: livekit.AutoTrackEgress tracks = 2; + */ + tracks?: AutoTrackEgress; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomEgress"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "message", T: RoomCompositeEgressRequest }, + { no: 3, name: "participant", kind: "message", T: AutoParticipantEgress }, + { no: 2, name: "tracks", kind: "message", T: AutoTrackEgress }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomEgress { + return new RoomEgress().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomEgress { + return new RoomEgress().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomEgress { + return new RoomEgress().fromJsonString(jsonString, options); + } + + static equals(a: RoomEgress | PlainMessage | undefined, b: RoomEgress | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomEgress, a, b); + } +} + +/** + * @generated from message livekit.RoomAgent + */ +export class RoomAgent extends Message { + /** + * @generated from field: repeated livekit.RoomAgentDispatch dispatches = 1; + */ + dispatches: RoomAgentDispatch[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomAgent"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "dispatches", kind: "message", T: RoomAgentDispatch, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomAgent { + return new RoomAgent().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomAgent { + return new RoomAgent().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomAgent { + return new RoomAgent().fromJsonString(jsonString, options); + } + + static equals(a: RoomAgent | PlainMessage | undefined, b: RoomAgent | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomAgent, a, b); + } +} + +/** + * @generated from message livekit.ListRoomsRequest + */ +export class ListRoomsRequest extends Message { + /** + * when set, will only return rooms with name match + * + * @generated from field: repeated string names = 1; + */ + names: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListRoomsRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "names", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListRoomsRequest { + return new ListRoomsRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListRoomsRequest { + return new ListRoomsRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListRoomsRequest { + return new ListRoomsRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListRoomsRequest | PlainMessage | undefined, b: ListRoomsRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListRoomsRequest, a, b); + } +} + +/** + * @generated from message livekit.ListRoomsResponse + */ +export class ListRoomsResponse extends Message { + /** + * @generated from field: repeated livekit.Room rooms = 1; + */ + rooms: Room[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListRoomsResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "rooms", kind: "message", T: Room, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListRoomsResponse { + return new ListRoomsResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListRoomsResponse { + return new ListRoomsResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListRoomsResponse { + return new ListRoomsResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListRoomsResponse | PlainMessage | undefined, b: ListRoomsResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListRoomsResponse, a, b); + } +} + +/** + * @generated from message livekit.DeleteRoomRequest + */ +export class DeleteRoomRequest extends Message { + /** + * name of the room + * + * @generated from field: string room = 1; + */ + room = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteRoomRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteRoomRequest { + return new DeleteRoomRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteRoomRequest { + return new DeleteRoomRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteRoomRequest { + return new DeleteRoomRequest().fromJsonString(jsonString, options); + } + + static equals(a: DeleteRoomRequest | PlainMessage | undefined, b: DeleteRoomRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteRoomRequest, a, b); + } +} + +/** + * @generated from message livekit.DeleteRoomResponse + */ +export class DeleteRoomResponse extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteRoomResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteRoomResponse { + return new DeleteRoomResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteRoomResponse { + return new DeleteRoomResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteRoomResponse { + return new DeleteRoomResponse().fromJsonString(jsonString, options); + } + + static equals(a: DeleteRoomResponse | PlainMessage | undefined, b: DeleteRoomResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteRoomResponse, a, b); + } +} + +/** + * @generated from message livekit.ListParticipantsRequest + */ +export class ListParticipantsRequest extends Message { + /** + * name of the room + * + * @generated from field: string room = 1; + */ + room = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListParticipantsRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListParticipantsRequest { + return new ListParticipantsRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListParticipantsRequest { + return new ListParticipantsRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListParticipantsRequest { + return new ListParticipantsRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListParticipantsRequest | PlainMessage | undefined, b: ListParticipantsRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListParticipantsRequest, a, b); + } +} + +/** + * @generated from message livekit.ListParticipantsResponse + */ +export class ListParticipantsResponse extends Message { + /** + * @generated from field: repeated livekit.ParticipantInfo participants = 1; + */ + participants: ParticipantInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListParticipantsResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participants", kind: "message", T: ParticipantInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListParticipantsResponse { + return new ListParticipantsResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListParticipantsResponse { + return new ListParticipantsResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListParticipantsResponse { + return new ListParticipantsResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListParticipantsResponse | PlainMessage | undefined, b: ListParticipantsResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListParticipantsResponse, a, b); + } +} + +/** + * @generated from message livekit.RoomParticipantIdentity + */ +export class RoomParticipantIdentity extends Message { + /** + * name of the room + * + * @generated from field: string room = 1; + */ + room = ""; + + /** + * identity of the participant + * + * @generated from field: string identity = 2; + */ + identity = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomParticipantIdentity"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomParticipantIdentity { + return new RoomParticipantIdentity().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomParticipantIdentity { + return new RoomParticipantIdentity().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomParticipantIdentity { + return new RoomParticipantIdentity().fromJsonString(jsonString, options); + } + + static equals(a: RoomParticipantIdentity | PlainMessage | undefined, b: RoomParticipantIdentity | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomParticipantIdentity, a, b); + } +} + +/** + * @generated from message livekit.RemoveParticipantResponse + */ +export class RemoveParticipantResponse extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RemoveParticipantResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RemoveParticipantResponse { + return new RemoveParticipantResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RemoveParticipantResponse { + return new RemoveParticipantResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RemoveParticipantResponse { + return new RemoveParticipantResponse().fromJsonString(jsonString, options); + } + + static equals(a: RemoveParticipantResponse | PlainMessage | undefined, b: RemoveParticipantResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(RemoveParticipantResponse, a, b); + } +} + +/** + * @generated from message livekit.MuteRoomTrackRequest + */ +export class MuteRoomTrackRequest extends Message { + /** + * name of the room + * + * @generated from field: string room = 1; + */ + room = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * sid of the track to mute + * + * @generated from field: string track_sid = 3; + */ + trackSid = ""; + + /** + * set to true to mute, false to unmute + * + * @generated from field: bool muted = 4; + */ + muted = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MuteRoomTrackRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MuteRoomTrackRequest { + return new MuteRoomTrackRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MuteRoomTrackRequest { + return new MuteRoomTrackRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MuteRoomTrackRequest { + return new MuteRoomTrackRequest().fromJsonString(jsonString, options); + } + + static equals(a: MuteRoomTrackRequest | PlainMessage | undefined, b: MuteRoomTrackRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(MuteRoomTrackRequest, a, b); + } +} + +/** + * @generated from message livekit.MuteRoomTrackResponse + */ +export class MuteRoomTrackResponse extends Message { + /** + * @generated from field: livekit.TrackInfo track = 1; + */ + track?: TrackInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MuteRoomTrackResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track", kind: "message", T: TrackInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MuteRoomTrackResponse { + return new MuteRoomTrackResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MuteRoomTrackResponse { + return new MuteRoomTrackResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MuteRoomTrackResponse { + return new MuteRoomTrackResponse().fromJsonString(jsonString, options); + } + + static equals(a: MuteRoomTrackResponse | PlainMessage | undefined, b: MuteRoomTrackResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(MuteRoomTrackResponse, a, b); + } +} + +/** + * @generated from message livekit.UpdateParticipantRequest + */ +export class UpdateParticipantRequest extends Message { + /** + * @generated from field: string room = 1; + */ + room = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * metadata to update. skipping updates if left empty + * + * @generated from field: string metadata = 3; + */ + metadata = ""; + + /** + * set to update the participant's permissions + * + * @generated from field: livekit.ParticipantPermission permission = 4; + */ + permission?: ParticipantPermission; + + /** + * display name to update + * + * @generated from field: string name = 5; + */ + name = ""; + + /** + * attributes to update. it only updates attributes that have been set + * to delete attributes, set the value to an empty string + * + * @generated from field: map attributes = 6; + */ + attributes: { [key: string]: string } = {}; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateParticipantRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "permission", kind: "message", T: ParticipantPermission }, + { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateParticipantRequest { + return new UpdateParticipantRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateParticipantRequest { + return new UpdateParticipantRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateParticipantRequest { + return new UpdateParticipantRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateParticipantRequest | PlainMessage | undefined, b: UpdateParticipantRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateParticipantRequest, a, b); + } +} + +/** + * @generated from message livekit.UpdateSubscriptionsRequest + */ +export class UpdateSubscriptionsRequest extends Message { + /** + * @generated from field: string room = 1; + */ + room = ""; + + /** + * @generated from field: string identity = 2; + */ + identity = ""; + + /** + * list of sids of tracks + * + * @generated from field: repeated string track_sids = 3; + */ + trackSids: string[] = []; + + /** + * set to true to subscribe, false to unsubscribe from tracks + * + * @generated from field: bool subscribe = 4; + */ + subscribe = false; + + /** + * list of participants and their tracks + * + * @generated from field: repeated livekit.ParticipantTracks participant_tracks = 5; + */ + participantTracks: ParticipantTracks[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateSubscriptionsRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "subscribe", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 5, name: "participant_tracks", kind: "message", T: ParticipantTracks, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateSubscriptionsRequest { + return new UpdateSubscriptionsRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateSubscriptionsRequest { + return new UpdateSubscriptionsRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateSubscriptionsRequest { + return new UpdateSubscriptionsRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateSubscriptionsRequest | PlainMessage | undefined, b: UpdateSubscriptionsRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateSubscriptionsRequest, a, b); + } +} + +/** + * empty for now + * + * @generated from message livekit.UpdateSubscriptionsResponse + */ +export class UpdateSubscriptionsResponse extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateSubscriptionsResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateSubscriptionsResponse { + return new UpdateSubscriptionsResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateSubscriptionsResponse { + return new UpdateSubscriptionsResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateSubscriptionsResponse { + return new UpdateSubscriptionsResponse().fromJsonString(jsonString, options); + } + + static equals(a: UpdateSubscriptionsResponse | PlainMessage | undefined, b: UpdateSubscriptionsResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateSubscriptionsResponse, a, b); + } +} + +/** + * @generated from message livekit.SendDataRequest + */ +export class SendDataRequest extends Message { + /** + * @generated from field: string room = 1; + */ + room = ""; + + /** + * @generated from field: bytes data = 2; + */ + data = new Uint8Array(0); + + /** + * @generated from field: livekit.DataPacket.Kind kind = 3; + */ + kind = DataPacket_Kind.RELIABLE; + + /** + * mark deprecated + * + * @generated from field: repeated string destination_sids = 4 [deprecated = true]; + * @deprecated + */ + destinationSids: string[] = []; + + /** + * when set, only forward to these identities + * + * @generated from field: repeated string destination_identities = 6; + */ + destinationIdentities: string[] = []; + + /** + * @generated from field: optional string topic = 5; + */ + topic?: string; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SendDataRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ }, + { no: 3, name: "kind", kind: "enum", T: proto3.getEnumType(DataPacket_Kind) }, + { no: 4, name: "destination_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 6, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 5, name: "topic", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SendDataRequest { + return new SendDataRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SendDataRequest { + return new SendDataRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SendDataRequest { + return new SendDataRequest().fromJsonString(jsonString, options); + } + + static equals(a: SendDataRequest | PlainMessage | undefined, b: SendDataRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SendDataRequest, a, b); + } +} + +/** + * @generated from message livekit.SendDataResponse + */ +export class SendDataResponse extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SendDataResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SendDataResponse { + return new SendDataResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SendDataResponse { + return new SendDataResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SendDataResponse { + return new SendDataResponse().fromJsonString(jsonString, options); + } + + static equals(a: SendDataResponse | PlainMessage | undefined, b: SendDataResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SendDataResponse, a, b); + } +} + +/** + * @generated from message livekit.UpdateRoomMetadataRequest + */ +export class UpdateRoomMetadataRequest extends Message { + /** + * @generated from field: string room = 1; + */ + room = ""; + + /** + * metadata to update. skipping updates if left empty + * + * @generated from field: string metadata = 2; + */ + metadata = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateRoomMetadataRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateRoomMetadataRequest { + return new UpdateRoomMetadataRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateRoomMetadataRequest { + return new UpdateRoomMetadataRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateRoomMetadataRequest { + return new UpdateRoomMetadataRequest().fromJsonString(jsonString, options); + } + + static equals(a: UpdateRoomMetadataRequest | PlainMessage | undefined, b: UpdateRoomMetadataRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateRoomMetadataRequest, a, b); + } +} + +/** + * @generated from message livekit.RoomConfiguration + */ +export class RoomConfiguration extends Message { + /** + * Used as ID, must be unique + * + * @generated from field: string name = 1; + */ + name = ""; + + /** + * number of seconds to keep the room open if no one joins + * + * @generated from field: uint32 empty_timeout = 2; + */ + emptyTimeout = 0; + + /** + * number of seconds to keep the room open after everyone leaves + * + * @generated from field: uint32 departure_timeout = 3; + */ + departureTimeout = 0; + + /** + * limit number of participants that can be in a room, excluding Egress and Ingress participants + * + * @generated from field: uint32 max_participants = 4; + */ + maxParticipants = 0; + + /** + * egress + * + * @generated from field: livekit.RoomEgress egress = 5; + */ + egress?: RoomEgress; + + /** + * playout delay of subscriber + * + * @generated from field: uint32 min_playout_delay = 7; + */ + minPlayoutDelay = 0; + + /** + * @generated from field: uint32 max_playout_delay = 8; + */ + maxPlayoutDelay = 0; + + /** + * improves A/V sync when playout_delay set to a value larger than 200ms. It will disables transceiver re-use + * so not recommended for rooms with frequent subscription changes + * + * @generated from field: bool sync_streams = 9; + */ + syncStreams = false; + + /** + * Define agents that should be dispatched to this room + * + * @generated from field: repeated livekit.RoomAgentDispatch agents = 10; + */ + agents: RoomAgentDispatch[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomConfiguration"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "empty_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "departure_timeout", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 4, name: "max_participants", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "egress", kind: "message", T: RoomEgress }, + { no: 7, name: "min_playout_delay", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 8, name: "max_playout_delay", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 9, name: "sync_streams", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 10, name: "agents", kind: "message", T: RoomAgentDispatch, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomConfiguration { + return new RoomConfiguration().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomConfiguration { + return new RoomConfiguration().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomConfiguration { + return new RoomConfiguration().fromJsonString(jsonString, options); + } + + static equals(a: RoomConfiguration | PlainMessage | undefined, b: RoomConfiguration | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomConfiguration, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_rtc_pb.ts b/packages/javascript/src/gen/livekit_rtc_pb.ts new file mode 100644 index 00000000..25e9818d --- /dev/null +++ b/packages/javascript/src/gen/livekit_rtc_pb.ts @@ -0,0 +1,2704 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_rtc.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { AudioTrackFeature, ClientConfiguration, Codec, ConnectionQuality, DisconnectReason, Encryption_Type, ParticipantInfo, ParticipantTracks, Room, ServerInfo, SpeakerInfo, SubscriptionError, TrackInfo, TrackSource, TrackType, VideoLayer, VideoQuality } from "./livekit_models_pb.js"; + +/** + * @generated from enum livekit.SignalTarget + */ +export enum SignalTarget { + /** + * @generated from enum value: PUBLISHER = 0; + */ + PUBLISHER = 0, + + /** + * @generated from enum value: SUBSCRIBER = 1; + */ + SUBSCRIBER = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(SignalTarget) +proto3.util.setEnumType(SignalTarget, "livekit.SignalTarget", [ + { no: 0, name: "PUBLISHER" }, + { no: 1, name: "SUBSCRIBER" }, +]); + +/** + * @generated from enum livekit.StreamState + */ +export enum StreamState { + /** + * @generated from enum value: ACTIVE = 0; + */ + ACTIVE = 0, + + /** + * @generated from enum value: PAUSED = 1; + */ + PAUSED = 1, +} +// Retrieve enum metadata with: proto3.getEnumType(StreamState) +proto3.util.setEnumType(StreamState, "livekit.StreamState", [ + { no: 0, name: "ACTIVE" }, + { no: 1, name: "PAUSED" }, +]); + +/** + * @generated from enum livekit.CandidateProtocol + */ +export enum CandidateProtocol { + /** + * @generated from enum value: UDP = 0; + */ + UDP = 0, + + /** + * @generated from enum value: TCP = 1; + */ + TCP = 1, + + /** + * @generated from enum value: TLS = 2; + */ + TLS = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(CandidateProtocol) +proto3.util.setEnumType(CandidateProtocol, "livekit.CandidateProtocol", [ + { no: 0, name: "UDP" }, + { no: 1, name: "TCP" }, + { no: 2, name: "TLS" }, +]); + +/** + * @generated from message livekit.SignalRequest + */ +export class SignalRequest extends Message { + /** + * @generated from oneof livekit.SignalRequest.message + */ + message: { + /** + * initial join exchange, for publisher + * + * @generated from field: livekit.SessionDescription offer = 1; + */ + value: SessionDescription; + case: "offer"; + } | { + /** + * participant answering publisher offer + * + * @generated from field: livekit.SessionDescription answer = 2; + */ + value: SessionDescription; + case: "answer"; + } | { + /** + * @generated from field: livekit.TrickleRequest trickle = 3; + */ + value: TrickleRequest; + case: "trickle"; + } | { + /** + * @generated from field: livekit.AddTrackRequest add_track = 4; + */ + value: AddTrackRequest; + case: "addTrack"; + } | { + /** + * mute the participant's published tracks + * + * @generated from field: livekit.MuteTrackRequest mute = 5; + */ + value: MuteTrackRequest; + case: "mute"; + } | { + /** + * Subscribe or unsubscribe from tracks + * + * @generated from field: livekit.UpdateSubscription subscription = 6; + */ + value: UpdateSubscription; + case: "subscription"; + } | { + /** + * Update settings of subscribed tracks + * + * @generated from field: livekit.UpdateTrackSettings track_setting = 7; + */ + value: UpdateTrackSettings; + case: "trackSetting"; + } | { + /** + * Immediately terminate session + * + * @generated from field: livekit.LeaveRequest leave = 8; + */ + value: LeaveRequest; + case: "leave"; + } | { + /** + * Update published video layers + * + * @generated from field: livekit.UpdateVideoLayers update_layers = 10 [deprecated = true]; + * @deprecated + */ + value: UpdateVideoLayers; + case: "updateLayers"; + } | { + /** + * Update subscriber permissions + * + * @generated from field: livekit.SubscriptionPermission subscription_permission = 11; + */ + value: SubscriptionPermission; + case: "subscriptionPermission"; + } | { + /** + * sync client's subscribe state to server during reconnect + * + * @generated from field: livekit.SyncState sync_state = 12; + */ + value: SyncState; + case: "syncState"; + } | { + /** + * Simulate conditions, for client validations + * + * @generated from field: livekit.SimulateScenario simulate = 13; + */ + value: SimulateScenario; + case: "simulate"; + } | { + /** + * client triggered ping to server + * + * deprecated by ping_req (message Ping) + * + * @generated from field: int64 ping = 14; + */ + value: bigint; + case: "ping"; + } | { + /** + * update a participant's own metadata, name, or attributes + * requires canUpdateOwnParticipantMetadata permission + * + * @generated from field: livekit.UpdateParticipantMetadata update_metadata = 15; + */ + value: UpdateParticipantMetadata; + case: "updateMetadata"; + } | { + /** + * @generated from field: livekit.Ping ping_req = 16; + */ + value: Ping; + case: "pingReq"; + } | { + /** + * Update local audio track settings + * + * @generated from field: livekit.UpdateLocalAudioTrack update_audio_track = 17; + */ + value: UpdateLocalAudioTrack; + case: "updateAudioTrack"; + } | { + /** + * Update local video track settings + * + * @generated from field: livekit.UpdateLocalVideoTrack update_video_track = 18; + */ + value: UpdateLocalVideoTrack; + case: "updateVideoTrack"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SignalRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "offer", kind: "message", T: SessionDescription, oneof: "message" }, + { no: 2, name: "answer", kind: "message", T: SessionDescription, oneof: "message" }, + { no: 3, name: "trickle", kind: "message", T: TrickleRequest, oneof: "message" }, + { no: 4, name: "add_track", kind: "message", T: AddTrackRequest, oneof: "message" }, + { no: 5, name: "mute", kind: "message", T: MuteTrackRequest, oneof: "message" }, + { no: 6, name: "subscription", kind: "message", T: UpdateSubscription, oneof: "message" }, + { no: 7, name: "track_setting", kind: "message", T: UpdateTrackSettings, oneof: "message" }, + { no: 8, name: "leave", kind: "message", T: LeaveRequest, oneof: "message" }, + { no: 10, name: "update_layers", kind: "message", T: UpdateVideoLayers, oneof: "message" }, + { no: 11, name: "subscription_permission", kind: "message", T: SubscriptionPermission, oneof: "message" }, + { no: 12, name: "sync_state", kind: "message", T: SyncState, oneof: "message" }, + { no: 13, name: "simulate", kind: "message", T: SimulateScenario, oneof: "message" }, + { no: 14, name: "ping", kind: "scalar", T: 3 /* ScalarType.INT64 */, oneof: "message" }, + { no: 15, name: "update_metadata", kind: "message", T: UpdateParticipantMetadata, oneof: "message" }, + { no: 16, name: "ping_req", kind: "message", T: Ping, oneof: "message" }, + { no: 17, name: "update_audio_track", kind: "message", T: UpdateLocalAudioTrack, oneof: "message" }, + { no: 18, name: "update_video_track", kind: "message", T: UpdateLocalVideoTrack, oneof: "message" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SignalRequest { + return new SignalRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SignalRequest { + return new SignalRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SignalRequest { + return new SignalRequest().fromJsonString(jsonString, options); + } + + static equals(a: SignalRequest | PlainMessage | undefined, b: SignalRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SignalRequest, a, b); + } +} + +/** + * @generated from message livekit.SignalResponse + */ +export class SignalResponse extends Message { + /** + * @generated from oneof livekit.SignalResponse.message + */ + message: { + /** + * sent when join is accepted + * + * @generated from field: livekit.JoinResponse join = 1; + */ + value: JoinResponse; + case: "join"; + } | { + /** + * sent when server answers publisher + * + * @generated from field: livekit.SessionDescription answer = 2; + */ + value: SessionDescription; + case: "answer"; + } | { + /** + * sent when server is sending subscriber an offer + * + * @generated from field: livekit.SessionDescription offer = 3; + */ + value: SessionDescription; + case: "offer"; + } | { + /** + * sent when an ICE candidate is available + * + * @generated from field: livekit.TrickleRequest trickle = 4; + */ + value: TrickleRequest; + case: "trickle"; + } | { + /** + * sent when participants in the room has changed + * + * @generated from field: livekit.ParticipantUpdate update = 5; + */ + value: ParticipantUpdate; + case: "update"; + } | { + /** + * sent to the participant when their track has been published + * + * @generated from field: livekit.TrackPublishedResponse track_published = 6; + */ + value: TrackPublishedResponse; + case: "trackPublished"; + } | { + /** + * Immediately terminate session + * + * @generated from field: livekit.LeaveRequest leave = 8; + */ + value: LeaveRequest; + case: "leave"; + } | { + /** + * server initiated mute + * + * @generated from field: livekit.MuteTrackRequest mute = 9; + */ + value: MuteTrackRequest; + case: "mute"; + } | { + /** + * indicates changes to speaker status, including when they've gone to not speaking + * + * @generated from field: livekit.SpeakersChanged speakers_changed = 10; + */ + value: SpeakersChanged; + case: "speakersChanged"; + } | { + /** + * sent when metadata of the room has changed + * + * @generated from field: livekit.RoomUpdate room_update = 11; + */ + value: RoomUpdate; + case: "roomUpdate"; + } | { + /** + * when connection quality changed + * + * @generated from field: livekit.ConnectionQualityUpdate connection_quality = 12; + */ + value: ConnectionQualityUpdate; + case: "connectionQuality"; + } | { + /** + * when streamed tracks state changed, used to notify when any of the streams were paused due to + * congestion + * + * @generated from field: livekit.StreamStateUpdate stream_state_update = 13; + */ + value: StreamStateUpdate; + case: "streamStateUpdate"; + } | { + /** + * when max subscribe quality changed, used by dynamic broadcasting to disable unused layers + * + * @generated from field: livekit.SubscribedQualityUpdate subscribed_quality_update = 14; + */ + value: SubscribedQualityUpdate; + case: "subscribedQualityUpdate"; + } | { + /** + * when subscription permission changed + * + * @generated from field: livekit.SubscriptionPermissionUpdate subscription_permission_update = 15; + */ + value: SubscriptionPermissionUpdate; + case: "subscriptionPermissionUpdate"; + } | { + /** + * update the token the client was using, to prevent an active client from using an expired token + * + * @generated from field: string refresh_token = 16; + */ + value: string; + case: "refreshToken"; + } | { + /** + * server initiated track unpublish + * + * @generated from field: livekit.TrackUnpublishedResponse track_unpublished = 17; + */ + value: TrackUnpublishedResponse; + case: "trackUnpublished"; + } | { + /** + * respond to ping + * + * deprecated by pong_resp (message Pong) + * + * @generated from field: int64 pong = 18; + */ + value: bigint; + case: "pong"; + } | { + /** + * sent when client reconnects + * + * @generated from field: livekit.ReconnectResponse reconnect = 19; + */ + value: ReconnectResponse; + case: "reconnect"; + } | { + /** + * respond to Ping + * + * @generated from field: livekit.Pong pong_resp = 20; + */ + value: Pong; + case: "pongResp"; + } | { + /** + * Subscription response, client should not expect any media from this subscription if it fails + * + * @generated from field: livekit.SubscriptionResponse subscription_response = 21; + */ + value: SubscriptionResponse; + case: "subscriptionResponse"; + } | { + /** + * Response relating to user inititated requests that carry a `request_id` + * + * @generated from field: livekit.RequestResponse request_response = 22; + */ + value: RequestResponse; + case: "requestResponse"; + } | { + /** + * notify to the publisher when a published track has been subscribed for the first time + * + * @generated from field: livekit.TrackSubscribed track_subscribed = 23; + */ + value: TrackSubscribed; + case: "trackSubscribed"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SignalResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "join", kind: "message", T: JoinResponse, oneof: "message" }, + { no: 2, name: "answer", kind: "message", T: SessionDescription, oneof: "message" }, + { no: 3, name: "offer", kind: "message", T: SessionDescription, oneof: "message" }, + { no: 4, name: "trickle", kind: "message", T: TrickleRequest, oneof: "message" }, + { no: 5, name: "update", kind: "message", T: ParticipantUpdate, oneof: "message" }, + { no: 6, name: "track_published", kind: "message", T: TrackPublishedResponse, oneof: "message" }, + { no: 8, name: "leave", kind: "message", T: LeaveRequest, oneof: "message" }, + { no: 9, name: "mute", kind: "message", T: MuteTrackRequest, oneof: "message" }, + { no: 10, name: "speakers_changed", kind: "message", T: SpeakersChanged, oneof: "message" }, + { no: 11, name: "room_update", kind: "message", T: RoomUpdate, oneof: "message" }, + { no: 12, name: "connection_quality", kind: "message", T: ConnectionQualityUpdate, oneof: "message" }, + { no: 13, name: "stream_state_update", kind: "message", T: StreamStateUpdate, oneof: "message" }, + { no: 14, name: "subscribed_quality_update", kind: "message", T: SubscribedQualityUpdate, oneof: "message" }, + { no: 15, name: "subscription_permission_update", kind: "message", T: SubscriptionPermissionUpdate, oneof: "message" }, + { no: 16, name: "refresh_token", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "message" }, + { no: 17, name: "track_unpublished", kind: "message", T: TrackUnpublishedResponse, oneof: "message" }, + { no: 18, name: "pong", kind: "scalar", T: 3 /* ScalarType.INT64 */, oneof: "message" }, + { no: 19, name: "reconnect", kind: "message", T: ReconnectResponse, oneof: "message" }, + { no: 20, name: "pong_resp", kind: "message", T: Pong, oneof: "message" }, + { no: 21, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" }, + { no: 22, name: "request_response", kind: "message", T: RequestResponse, oneof: "message" }, + { no: 23, name: "track_subscribed", kind: "message", T: TrackSubscribed, oneof: "message" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SignalResponse { + return new SignalResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SignalResponse { + return new SignalResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SignalResponse { + return new SignalResponse().fromJsonString(jsonString, options); + } + + static equals(a: SignalResponse | PlainMessage | undefined, b: SignalResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SignalResponse, a, b); + } +} + +/** + * @generated from message livekit.SimulcastCodec + */ +export class SimulcastCodec extends Message { + /** + * @generated from field: string codec = 1; + */ + codec = ""; + + /** + * @generated from field: string cid = 2; + */ + cid = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SimulcastCodec"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "codec", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SimulcastCodec { + return new SimulcastCodec().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SimulcastCodec { + return new SimulcastCodec().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SimulcastCodec { + return new SimulcastCodec().fromJsonString(jsonString, options); + } + + static equals(a: SimulcastCodec | PlainMessage | undefined, b: SimulcastCodec | PlainMessage | undefined): boolean { + return proto3.util.equals(SimulcastCodec, a, b); + } +} + +/** + * @generated from message livekit.AddTrackRequest + */ +export class AddTrackRequest extends Message { + /** + * client ID of track, to match it when RTC track is received + * + * @generated from field: string cid = 1; + */ + cid = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * @generated from field: livekit.TrackType type = 3; + */ + type = TrackType.AUDIO; + + /** + * to be deprecated in favor of layers + * + * @generated from field: uint32 width = 4; + */ + width = 0; + + /** + * @generated from field: uint32 height = 5; + */ + height = 0; + + /** + * true to add track and initialize to muted + * + * @generated from field: bool muted = 6; + */ + muted = false; + + /** + * true if DTX (Discontinuous Transmission) is disabled for audio + * + * @generated from field: bool disable_dtx = 7; + */ + disableDtx = false; + + /** + * @generated from field: livekit.TrackSource source = 8; + */ + source = TrackSource.UNKNOWN; + + /** + * @generated from field: repeated livekit.VideoLayer layers = 9; + */ + layers: VideoLayer[] = []; + + /** + * @generated from field: repeated livekit.SimulcastCodec simulcast_codecs = 10; + */ + simulcastCodecs: SimulcastCodec[] = []; + + /** + * server ID of track, publish new codec to exist track + * + * @generated from field: string sid = 11; + */ + sid = ""; + + /** + * @generated from field: bool stereo = 12; + */ + stereo = false; + + /** + * true if RED (Redundant Encoding) is disabled for audio + * + * @generated from field: bool disable_red = 13; + */ + disableRed = false; + + /** + * @generated from field: livekit.Encryption.Type encryption = 14; + */ + encryption = Encryption_Type.NONE; + + /** + * which stream the track belongs to, used to group tracks together. + * if not specified, server will infer it from track source to bundle camera/microphone, screenshare/audio together + * + * @generated from field: string stream = 15; + */ + stream = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.AddTrackRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "type", kind: "enum", T: proto3.getEnumType(TrackType) }, + { no: 4, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 6, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 7, name: "disable_dtx", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 8, name: "source", kind: "enum", T: proto3.getEnumType(TrackSource) }, + { no: 9, name: "layers", kind: "message", T: VideoLayer, repeated: true }, + { no: 10, name: "simulcast_codecs", kind: "message", T: SimulcastCodec, repeated: true }, + { no: 11, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 12, name: "stereo", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 13, name: "disable_red", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 14, name: "encryption", kind: "enum", T: proto3.getEnumType(Encryption_Type) }, + { no: 15, name: "stream", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): AddTrackRequest { + return new AddTrackRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): AddTrackRequest { + return new AddTrackRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): AddTrackRequest { + return new AddTrackRequest().fromJsonString(jsonString, options); + } + + static equals(a: AddTrackRequest | PlainMessage | undefined, b: AddTrackRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(AddTrackRequest, a, b); + } +} + +/** + * @generated from message livekit.TrickleRequest + */ +export class TrickleRequest extends Message { + /** + * @generated from field: string candidateInit = 1; + */ + candidateInit = ""; + + /** + * @generated from field: livekit.SignalTarget target = 2; + */ + target = SignalTarget.PUBLISHER; + + /** + * @generated from field: bool final = 3; + */ + final = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrickleRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "candidateInit", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "target", kind: "enum", T: proto3.getEnumType(SignalTarget) }, + { no: 3, name: "final", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrickleRequest { + return new TrickleRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrickleRequest { + return new TrickleRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrickleRequest { + return new TrickleRequest().fromJsonString(jsonString, options); + } + + static equals(a: TrickleRequest | PlainMessage | undefined, b: TrickleRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(TrickleRequest, a, b); + } +} + +/** + * @generated from message livekit.MuteTrackRequest + */ +export class MuteTrackRequest extends Message { + /** + * @generated from field: string sid = 1; + */ + sid = ""; + + /** + * @generated from field: bool muted = 2; + */ + muted = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.MuteTrackRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): MuteTrackRequest { + return new MuteTrackRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): MuteTrackRequest { + return new MuteTrackRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): MuteTrackRequest { + return new MuteTrackRequest().fromJsonString(jsonString, options); + } + + static equals(a: MuteTrackRequest | PlainMessage | undefined, b: MuteTrackRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(MuteTrackRequest, a, b); + } +} + +/** + * @generated from message livekit.JoinResponse + */ +export class JoinResponse extends Message { + /** + * @generated from field: livekit.Room room = 1; + */ + room?: Room; + + /** + * @generated from field: livekit.ParticipantInfo participant = 2; + */ + participant?: ParticipantInfo; + + /** + * @generated from field: repeated livekit.ParticipantInfo other_participants = 3; + */ + otherParticipants: ParticipantInfo[] = []; + + /** + * deprecated. use server_info.version instead. + * + * @generated from field: string server_version = 4; + */ + serverVersion = ""; + + /** + * @generated from field: repeated livekit.ICEServer ice_servers = 5; + */ + iceServers: ICEServer[] = []; + + /** + * use subscriber as the primary PeerConnection + * + * @generated from field: bool subscriber_primary = 6; + */ + subscriberPrimary = false; + + /** + * when the current server isn't available, return alternate url to retry connection + * when this is set, the other fields will be largely empty + * + * @generated from field: string alternative_url = 7; + */ + alternativeUrl = ""; + + /** + * @generated from field: livekit.ClientConfiguration client_configuration = 8; + */ + clientConfiguration?: ClientConfiguration; + + /** + * deprecated. use server_info.region instead. + * + * @generated from field: string server_region = 9; + */ + serverRegion = ""; + + /** + * @generated from field: int32 ping_timeout = 10; + */ + pingTimeout = 0; + + /** + * @generated from field: int32 ping_interval = 11; + */ + pingInterval = 0; + + /** + * @generated from field: livekit.ServerInfo server_info = 12; + */ + serverInfo?: ServerInfo; + + /** + * Server-Injected-Frame byte trailer, used to identify unencrypted frames when e2ee is enabled + * + * @generated from field: bytes sif_trailer = 13; + */ + sifTrailer = new Uint8Array(0); + + /** + * @generated from field: repeated livekit.Codec enabled_publish_codecs = 14; + */ + enabledPublishCodecs: Codec[] = []; + + /** + * when set, client should attempt to establish publish peer connection when joining room to speed up publishing + * + * @generated from field: bool fast_publish = 15; + */ + fastPublish = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.JoinResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "message", T: Room }, + { no: 2, name: "participant", kind: "message", T: ParticipantInfo }, + { no: 3, name: "other_participants", kind: "message", T: ParticipantInfo, repeated: true }, + { no: 4, name: "server_version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "ice_servers", kind: "message", T: ICEServer, repeated: true }, + { no: 6, name: "subscriber_primary", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 7, name: "alternative_url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "client_configuration", kind: "message", T: ClientConfiguration }, + { no: 9, name: "server_region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "ping_timeout", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 11, name: "ping_interval", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + { no: 12, name: "server_info", kind: "message", T: ServerInfo }, + { no: 13, name: "sif_trailer", kind: "scalar", T: 12 /* ScalarType.BYTES */ }, + { no: 14, name: "enabled_publish_codecs", kind: "message", T: Codec, repeated: true }, + { no: 15, name: "fast_publish", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): JoinResponse { + return new JoinResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): JoinResponse { + return new JoinResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): JoinResponse { + return new JoinResponse().fromJsonString(jsonString, options); + } + + static equals(a: JoinResponse | PlainMessage | undefined, b: JoinResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(JoinResponse, a, b); + } +} + +/** + * @generated from message livekit.ReconnectResponse + */ +export class ReconnectResponse extends Message { + /** + * @generated from field: repeated livekit.ICEServer ice_servers = 1; + */ + iceServers: ICEServer[] = []; + + /** + * @generated from field: livekit.ClientConfiguration client_configuration = 2; + */ + clientConfiguration?: ClientConfiguration; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ReconnectResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "ice_servers", kind: "message", T: ICEServer, repeated: true }, + { no: 2, name: "client_configuration", kind: "message", T: ClientConfiguration }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ReconnectResponse { + return new ReconnectResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ReconnectResponse { + return new ReconnectResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ReconnectResponse { + return new ReconnectResponse().fromJsonString(jsonString, options); + } + + static equals(a: ReconnectResponse | PlainMessage | undefined, b: ReconnectResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ReconnectResponse, a, b); + } +} + +/** + * @generated from message livekit.TrackPublishedResponse + */ +export class TrackPublishedResponse extends Message { + /** + * @generated from field: string cid = 1; + */ + cid = ""; + + /** + * @generated from field: livekit.TrackInfo track = 2; + */ + track?: TrackInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackPublishedResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "track", kind: "message", T: TrackInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackPublishedResponse { + return new TrackPublishedResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackPublishedResponse { + return new TrackPublishedResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackPublishedResponse { + return new TrackPublishedResponse().fromJsonString(jsonString, options); + } + + static equals(a: TrackPublishedResponse | PlainMessage | undefined, b: TrackPublishedResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackPublishedResponse, a, b); + } +} + +/** + * @generated from message livekit.TrackUnpublishedResponse + */ +export class TrackUnpublishedResponse extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackUnpublishedResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackUnpublishedResponse { + return new TrackUnpublishedResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackUnpublishedResponse { + return new TrackUnpublishedResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackUnpublishedResponse { + return new TrackUnpublishedResponse().fromJsonString(jsonString, options); + } + + static equals(a: TrackUnpublishedResponse | PlainMessage | undefined, b: TrackUnpublishedResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackUnpublishedResponse, a, b); + } +} + +/** + * @generated from message livekit.SessionDescription + */ +export class SessionDescription extends Message { + /** + * "answer" | "offer" | "pranswer" | "rollback" + * + * @generated from field: string type = 1; + */ + type = ""; + + /** + * @generated from field: string sdp = 2; + */ + sdp = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SessionDescription"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "sdp", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SessionDescription { + return new SessionDescription().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SessionDescription { + return new SessionDescription().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SessionDescription { + return new SessionDescription().fromJsonString(jsonString, options); + } + + static equals(a: SessionDescription | PlainMessage | undefined, b: SessionDescription | PlainMessage | undefined): boolean { + return proto3.util.equals(SessionDescription, a, b); + } +} + +/** + * @generated from message livekit.ParticipantUpdate + */ +export class ParticipantUpdate extends Message { + /** + * @generated from field: repeated livekit.ParticipantInfo participants = 1; + */ + participants: ParticipantInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ParticipantUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participants", kind: "message", T: ParticipantInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ParticipantUpdate { + return new ParticipantUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ParticipantUpdate { + return new ParticipantUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ParticipantUpdate { + return new ParticipantUpdate().fromJsonString(jsonString, options); + } + + static equals(a: ParticipantUpdate | PlainMessage | undefined, b: ParticipantUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(ParticipantUpdate, a, b); + } +} + +/** + * @generated from message livekit.UpdateSubscription + */ +export class UpdateSubscription extends Message { + /** + * @generated from field: repeated string track_sids = 1; + */ + trackSids: string[] = []; + + /** + * @generated from field: bool subscribe = 2; + */ + subscribe = false; + + /** + * @generated from field: repeated livekit.ParticipantTracks participant_tracks = 3; + */ + participantTracks: ParticipantTracks[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateSubscription"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 2, name: "subscribe", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "participant_tracks", kind: "message", T: ParticipantTracks, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateSubscription { + return new UpdateSubscription().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateSubscription { + return new UpdateSubscription().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateSubscription { + return new UpdateSubscription().fromJsonString(jsonString, options); + } + + static equals(a: UpdateSubscription | PlainMessage | undefined, b: UpdateSubscription | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateSubscription, a, b); + } +} + +/** + * @generated from message livekit.UpdateTrackSettings + */ +export class UpdateTrackSettings extends Message { + /** + * @generated from field: repeated string track_sids = 1; + */ + trackSids: string[] = []; + + /** + * when true, the track is placed in a paused state, with no new data returned + * + * @generated from field: bool disabled = 3; + */ + disabled = false; + + /** + * deprecated in favor of width & height + * + * @generated from field: livekit.VideoQuality quality = 4; + */ + quality = VideoQuality.LOW; + + /** + * for video, width to receive + * + * @generated from field: uint32 width = 5; + */ + width = 0; + + /** + * for video, height to receive + * + * @generated from field: uint32 height = 6; + */ + height = 0; + + /** + * @generated from field: uint32 fps = 7; + */ + fps = 0; + + /** + * subscription priority. 1 being the highest (0 is unset) + * when unset, server sill assign priority based on the order of subscription + * server will use priority in the following ways: + * 1. when subscribed tracks exceed per-participant subscription limit, server will + * pause the lowest priority tracks + * 2. when the network is congested, server will assign available bandwidth to + * higher priority tracks first. lowest priority tracks can be paused + * + * @generated from field: uint32 priority = 8; + */ + priority = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateTrackSettings"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 3, name: "disabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 4, name: "quality", kind: "enum", T: proto3.getEnumType(VideoQuality) }, + { no: 5, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 6, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 7, name: "fps", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 8, name: "priority", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateTrackSettings { + return new UpdateTrackSettings().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateTrackSettings { + return new UpdateTrackSettings().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateTrackSettings { + return new UpdateTrackSettings().fromJsonString(jsonString, options); + } + + static equals(a: UpdateTrackSettings | PlainMessage | undefined, b: UpdateTrackSettings | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateTrackSettings, a, b); + } +} + +/** + * @generated from message livekit.UpdateLocalAudioTrack + */ +export class UpdateLocalAudioTrack extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + /** + * @generated from field: repeated livekit.AudioTrackFeature features = 2; + */ + features: AudioTrackFeature[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateLocalAudioTrack"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "features", kind: "enum", T: proto3.getEnumType(AudioTrackFeature), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateLocalAudioTrack { + return new UpdateLocalAudioTrack().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateLocalAudioTrack { + return new UpdateLocalAudioTrack().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateLocalAudioTrack { + return new UpdateLocalAudioTrack().fromJsonString(jsonString, options); + } + + static equals(a: UpdateLocalAudioTrack | PlainMessage | undefined, b: UpdateLocalAudioTrack | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateLocalAudioTrack, a, b); + } +} + +/** + * @generated from message livekit.UpdateLocalVideoTrack + */ +export class UpdateLocalVideoTrack extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + /** + * @generated from field: uint32 width = 2; + */ + width = 0; + + /** + * @generated from field: uint32 height = 3; + */ + height = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateLocalVideoTrack"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateLocalVideoTrack { + return new UpdateLocalVideoTrack().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateLocalVideoTrack { + return new UpdateLocalVideoTrack().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateLocalVideoTrack { + return new UpdateLocalVideoTrack().fromJsonString(jsonString, options); + } + + static equals(a: UpdateLocalVideoTrack | PlainMessage | undefined, b: UpdateLocalVideoTrack | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateLocalVideoTrack, a, b); + } +} + +/** + * @generated from message livekit.LeaveRequest + */ +export class LeaveRequest extends Message { + /** + * sent when server initiates the disconnect due to server-restart + * indicates clients should attempt full-reconnect sequence + * NOTE: `can_reconnect` obsoleted by `action` starting in protocol version 13 + * + * @generated from field: bool can_reconnect = 1; + */ + canReconnect = false; + + /** + * @generated from field: livekit.DisconnectReason reason = 2; + */ + reason = DisconnectReason.UNKNOWN_REASON; + + /** + * @generated from field: livekit.LeaveRequest.Action action = 3; + */ + action = LeaveRequest_Action.DISCONNECT; + + /** + * @generated from field: livekit.RegionSettings regions = 4; + */ + regions?: RegionSettings; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.LeaveRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "can_reconnect", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "reason", kind: "enum", T: proto3.getEnumType(DisconnectReason) }, + { no: 3, name: "action", kind: "enum", T: proto3.getEnumType(LeaveRequest_Action) }, + { no: 4, name: "regions", kind: "message", T: RegionSettings }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): LeaveRequest { + return new LeaveRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): LeaveRequest { + return new LeaveRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): LeaveRequest { + return new LeaveRequest().fromJsonString(jsonString, options); + } + + static equals(a: LeaveRequest | PlainMessage | undefined, b: LeaveRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(LeaveRequest, a, b); + } +} + +/** + * indicates action clients should take on receiving this message + * + * @generated from enum livekit.LeaveRequest.Action + */ +export enum LeaveRequest_Action { + /** + * should disconnect + * + * @generated from enum value: DISCONNECT = 0; + */ + DISCONNECT = 0, + + /** + * should attempt a resume with `reconnect=1` in join URL + * + * @generated from enum value: RESUME = 1; + */ + RESUME = 1, + + /** + * should attempt a reconnect, i. e. no `reconnect=1` + * + * @generated from enum value: RECONNECT = 2; + */ + RECONNECT = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(LeaveRequest_Action) +proto3.util.setEnumType(LeaveRequest_Action, "livekit.LeaveRequest.Action", [ + { no: 0, name: "DISCONNECT" }, + { no: 1, name: "RESUME" }, + { no: 2, name: "RECONNECT" }, +]); + +/** + * message to indicate published video track dimensions are changing + * + * @generated from message livekit.UpdateVideoLayers + * @deprecated + */ +export class UpdateVideoLayers extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + /** + * @generated from field: repeated livekit.VideoLayer layers = 2; + */ + layers: VideoLayer[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateVideoLayers"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "layers", kind: "message", T: VideoLayer, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateVideoLayers { + return new UpdateVideoLayers().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateVideoLayers { + return new UpdateVideoLayers().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateVideoLayers { + return new UpdateVideoLayers().fromJsonString(jsonString, options); + } + + static equals(a: UpdateVideoLayers | PlainMessage | undefined, b: UpdateVideoLayers | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateVideoLayers, a, b); + } +} + +/** + * @generated from message livekit.UpdateParticipantMetadata + */ +export class UpdateParticipantMetadata extends Message { + /** + * @generated from field: string metadata = 1; + */ + metadata = ""; + + /** + * @generated from field: string name = 2; + */ + name = ""; + + /** + * attributes to update. it only updates attributes that have been set + * to delete attributes, set the value to an empty string + * + * @generated from field: map attributes = 3; + */ + attributes: { [key: string]: string } = {}; + + /** + * @generated from field: uint32 request_id = 4; + */ + requestId = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.UpdateParticipantMetadata"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 4, name: "request_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): UpdateParticipantMetadata { + return new UpdateParticipantMetadata().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): UpdateParticipantMetadata { + return new UpdateParticipantMetadata().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): UpdateParticipantMetadata { + return new UpdateParticipantMetadata().fromJsonString(jsonString, options); + } + + static equals(a: UpdateParticipantMetadata | PlainMessage | undefined, b: UpdateParticipantMetadata | PlainMessage | undefined): boolean { + return proto3.util.equals(UpdateParticipantMetadata, a, b); + } +} + +/** + * @generated from message livekit.ICEServer + */ +export class ICEServer extends Message { + /** + * @generated from field: repeated string urls = 1; + */ + urls: string[] = []; + + /** + * @generated from field: string username = 2; + */ + username = ""; + + /** + * @generated from field: string credential = 3; + */ + credential = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ICEServer"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 2, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "credential", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ICEServer { + return new ICEServer().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ICEServer { + return new ICEServer().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ICEServer { + return new ICEServer().fromJsonString(jsonString, options); + } + + static equals(a: ICEServer | PlainMessage | undefined, b: ICEServer | PlainMessage | undefined): boolean { + return proto3.util.equals(ICEServer, a, b); + } +} + +/** + * @generated from message livekit.SpeakersChanged + */ +export class SpeakersChanged extends Message { + /** + * @generated from field: repeated livekit.SpeakerInfo speakers = 1; + */ + speakers: SpeakerInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SpeakersChanged"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "speakers", kind: "message", T: SpeakerInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SpeakersChanged { + return new SpeakersChanged().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SpeakersChanged { + return new SpeakersChanged().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SpeakersChanged { + return new SpeakersChanged().fromJsonString(jsonString, options); + } + + static equals(a: SpeakersChanged | PlainMessage | undefined, b: SpeakersChanged | PlainMessage | undefined): boolean { + return proto3.util.equals(SpeakersChanged, a, b); + } +} + +/** + * @generated from message livekit.RoomUpdate + */ +export class RoomUpdate extends Message { + /** + * @generated from field: livekit.Room room = 1; + */ + room?: Room; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RoomUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room", kind: "message", T: Room }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RoomUpdate { + return new RoomUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RoomUpdate { + return new RoomUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RoomUpdate { + return new RoomUpdate().fromJsonString(jsonString, options); + } + + static equals(a: RoomUpdate | PlainMessage | undefined, b: RoomUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(RoomUpdate, a, b); + } +} + +/** + * @generated from message livekit.ConnectionQualityInfo + */ +export class ConnectionQualityInfo extends Message { + /** + * @generated from field: string participant_sid = 1; + */ + participantSid = ""; + + /** + * @generated from field: livekit.ConnectionQuality quality = 2; + */ + quality = ConnectionQuality.POOR; + + /** + * @generated from field: float score = 3; + */ + score = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ConnectionQualityInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "quality", kind: "enum", T: proto3.getEnumType(ConnectionQuality) }, + { no: 3, name: "score", kind: "scalar", T: 2 /* ScalarType.FLOAT */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ConnectionQualityInfo { + return new ConnectionQualityInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ConnectionQualityInfo { + return new ConnectionQualityInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ConnectionQualityInfo { + return new ConnectionQualityInfo().fromJsonString(jsonString, options); + } + + static equals(a: ConnectionQualityInfo | PlainMessage | undefined, b: ConnectionQualityInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(ConnectionQualityInfo, a, b); + } +} + +/** + * @generated from message livekit.ConnectionQualityUpdate + */ +export class ConnectionQualityUpdate extends Message { + /** + * @generated from field: repeated livekit.ConnectionQualityInfo updates = 1; + */ + updates: ConnectionQualityInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ConnectionQualityUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: ConnectionQualityInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ConnectionQualityUpdate { + return new ConnectionQualityUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ConnectionQualityUpdate { + return new ConnectionQualityUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ConnectionQualityUpdate { + return new ConnectionQualityUpdate().fromJsonString(jsonString, options); + } + + static equals(a: ConnectionQualityUpdate | PlainMessage | undefined, b: ConnectionQualityUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(ConnectionQualityUpdate, a, b); + } +} + +/** + * @generated from message livekit.StreamStateInfo + */ +export class StreamStateInfo extends Message { + /** + * @generated from field: string participant_sid = 1; + */ + participantSid = ""; + + /** + * @generated from field: string track_sid = 2; + */ + trackSid = ""; + + /** + * @generated from field: livekit.StreamState state = 3; + */ + state = StreamState.ACTIVE; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StreamStateInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "state", kind: "enum", T: proto3.getEnumType(StreamState) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamStateInfo { + return new StreamStateInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamStateInfo { + return new StreamStateInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamStateInfo { + return new StreamStateInfo().fromJsonString(jsonString, options); + } + + static equals(a: StreamStateInfo | PlainMessage | undefined, b: StreamStateInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamStateInfo, a, b); + } +} + +/** + * @generated from message livekit.StreamStateUpdate + */ +export class StreamStateUpdate extends Message { + /** + * @generated from field: repeated livekit.StreamStateInfo stream_states = 1; + */ + streamStates: StreamStateInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.StreamStateUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "stream_states", kind: "message", T: StreamStateInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamStateUpdate { + return new StreamStateUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamStateUpdate { + return new StreamStateUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamStateUpdate { + return new StreamStateUpdate().fromJsonString(jsonString, options); + } + + static equals(a: StreamStateUpdate | PlainMessage | undefined, b: StreamStateUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamStateUpdate, a, b); + } +} + +/** + * @generated from message livekit.SubscribedQuality + */ +export class SubscribedQuality extends Message { + /** + * @generated from field: livekit.VideoQuality quality = 1; + */ + quality = VideoQuality.LOW; + + /** + * @generated from field: bool enabled = 2; + */ + enabled = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscribedQuality"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "quality", kind: "enum", T: proto3.getEnumType(VideoQuality) }, + { no: 2, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribedQuality { + return new SubscribedQuality().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribedQuality { + return new SubscribedQuality().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribedQuality { + return new SubscribedQuality().fromJsonString(jsonString, options); + } + + static equals(a: SubscribedQuality | PlainMessage | undefined, b: SubscribedQuality | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribedQuality, a, b); + } +} + +/** + * @generated from message livekit.SubscribedCodec + */ +export class SubscribedCodec extends Message { + /** + * @generated from field: string codec = 1; + */ + codec = ""; + + /** + * @generated from field: repeated livekit.SubscribedQuality qualities = 2; + */ + qualities: SubscribedQuality[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscribedCodec"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "codec", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "qualities", kind: "message", T: SubscribedQuality, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribedCodec { + return new SubscribedCodec().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribedCodec { + return new SubscribedCodec().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribedCodec { + return new SubscribedCodec().fromJsonString(jsonString, options); + } + + static equals(a: SubscribedCodec | PlainMessage | undefined, b: SubscribedCodec | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribedCodec, a, b); + } +} + +/** + * @generated from message livekit.SubscribedQualityUpdate + */ +export class SubscribedQualityUpdate extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + /** + * @generated from field: repeated livekit.SubscribedQuality subscribed_qualities = 2; + */ + subscribedQualities: SubscribedQuality[] = []; + + /** + * @generated from field: repeated livekit.SubscribedCodec subscribed_codecs = 3; + */ + subscribedCodecs: SubscribedCodec[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscribedQualityUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "subscribed_qualities", kind: "message", T: SubscribedQuality, repeated: true }, + { no: 3, name: "subscribed_codecs", kind: "message", T: SubscribedCodec, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribedQualityUpdate { + return new SubscribedQualityUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribedQualityUpdate { + return new SubscribedQualityUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribedQualityUpdate { + return new SubscribedQualityUpdate().fromJsonString(jsonString, options); + } + + static equals(a: SubscribedQualityUpdate | PlainMessage | undefined, b: SubscribedQualityUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribedQualityUpdate, a, b); + } +} + +/** + * @generated from message livekit.TrackPermission + */ +export class TrackPermission extends Message { + /** + * permission could be granted either by participant sid or identity + * + * @generated from field: string participant_sid = 1; + */ + participantSid = ""; + + /** + * @generated from field: bool all_tracks = 2; + */ + allTracks = false; + + /** + * @generated from field: repeated string track_sids = 3; + */ + trackSids: string[] = []; + + /** + * @generated from field: string participant_identity = 4; + */ + participantIdentity = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackPermission"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "all_tracks", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 3, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackPermission { + return new TrackPermission().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackPermission { + return new TrackPermission().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackPermission { + return new TrackPermission().fromJsonString(jsonString, options); + } + + static equals(a: TrackPermission | PlainMessage | undefined, b: TrackPermission | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackPermission, a, b); + } +} + +/** + * @generated from message livekit.SubscriptionPermission + */ +export class SubscriptionPermission extends Message { + /** + * @generated from field: bool all_participants = 1; + */ + allParticipants = false; + + /** + * @generated from field: repeated livekit.TrackPermission track_permissions = 2; + */ + trackPermissions: TrackPermission[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscriptionPermission"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "all_participants", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 2, name: "track_permissions", kind: "message", T: TrackPermission, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscriptionPermission { + return new SubscriptionPermission().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscriptionPermission { + return new SubscriptionPermission().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscriptionPermission { + return new SubscriptionPermission().fromJsonString(jsonString, options); + } + + static equals(a: SubscriptionPermission | PlainMessage | undefined, b: SubscriptionPermission | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscriptionPermission, a, b); + } +} + +/** + * @generated from message livekit.SubscriptionPermissionUpdate + */ +export class SubscriptionPermissionUpdate extends Message { + /** + * @generated from field: string participant_sid = 1; + */ + participantSid = ""; + + /** + * @generated from field: string track_sid = 2; + */ + trackSid = ""; + + /** + * @generated from field: bool allowed = 3; + */ + allowed = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscriptionPermissionUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "allowed", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscriptionPermissionUpdate { + return new SubscriptionPermissionUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscriptionPermissionUpdate { + return new SubscriptionPermissionUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscriptionPermissionUpdate { + return new SubscriptionPermissionUpdate().fromJsonString(jsonString, options); + } + + static equals(a: SubscriptionPermissionUpdate | PlainMessage | undefined, b: SubscriptionPermissionUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscriptionPermissionUpdate, a, b); + } +} + +/** + * @generated from message livekit.SyncState + */ +export class SyncState extends Message { + /** + * last subscribe answer before reconnecting + * + * @generated from field: livekit.SessionDescription answer = 1; + */ + answer?: SessionDescription; + + /** + * @generated from field: livekit.UpdateSubscription subscription = 2; + */ + subscription?: UpdateSubscription; + + /** + * @generated from field: repeated livekit.TrackPublishedResponse publish_tracks = 3; + */ + publishTracks: TrackPublishedResponse[] = []; + + /** + * @generated from field: repeated livekit.DataChannelInfo data_channels = 4; + */ + dataChannels: DataChannelInfo[] = []; + + /** + * last received server side offer before reconnecting + * + * @generated from field: livekit.SessionDescription offer = 5; + */ + offer?: SessionDescription; + + /** + * @generated from field: repeated string track_sids_disabled = 6; + */ + trackSidsDisabled: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SyncState"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "answer", kind: "message", T: SessionDescription }, + { no: 2, name: "subscription", kind: "message", T: UpdateSubscription }, + { no: 3, name: "publish_tracks", kind: "message", T: TrackPublishedResponse, repeated: true }, + { no: 4, name: "data_channels", kind: "message", T: DataChannelInfo, repeated: true }, + { no: 5, name: "offer", kind: "message", T: SessionDescription }, + { no: 6, name: "track_sids_disabled", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SyncState { + return new SyncState().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SyncState { + return new SyncState().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SyncState { + return new SyncState().fromJsonString(jsonString, options); + } + + static equals(a: SyncState | PlainMessage | undefined, b: SyncState | PlainMessage | undefined): boolean { + return proto3.util.equals(SyncState, a, b); + } +} + +/** + * @generated from message livekit.DataChannelInfo + */ +export class DataChannelInfo extends Message { + /** + * @generated from field: string label = 1; + */ + label = ""; + + /** + * @generated from field: uint32 id = 2; + */ + id = 0; + + /** + * @generated from field: livekit.SignalTarget target = 3; + */ + target = SignalTarget.PUBLISHER; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DataChannelInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "label", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 3, name: "target", kind: "enum", T: proto3.getEnumType(SignalTarget) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataChannelInfo { + return new DataChannelInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataChannelInfo { + return new DataChannelInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataChannelInfo { + return new DataChannelInfo().fromJsonString(jsonString, options); + } + + static equals(a: DataChannelInfo | PlainMessage | undefined, b: DataChannelInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(DataChannelInfo, a, b); + } +} + +/** + * @generated from message livekit.SimulateScenario + */ +export class SimulateScenario extends Message { + /** + * @generated from oneof livekit.SimulateScenario.scenario + */ + scenario: { + /** + * simulate N seconds of speaker activity + * + * @generated from field: int32 speaker_update = 1; + */ + value: number; + case: "speakerUpdate"; + } | { + /** + * simulate local node failure + * + * @generated from field: bool node_failure = 2; + */ + value: boolean; + case: "nodeFailure"; + } | { + /** + * simulate migration + * + * @generated from field: bool migration = 3; + */ + value: boolean; + case: "migration"; + } | { + /** + * server to send leave + * + * @generated from field: bool server_leave = 4; + */ + value: boolean; + case: "serverLeave"; + } | { + /** + * switch candidate protocol to tcp + * + * @generated from field: livekit.CandidateProtocol switch_candidate_protocol = 5; + */ + value: CandidateProtocol; + case: "switchCandidateProtocol"; + } | { + /** + * maximum bandwidth for subscribers, in bps + * when zero, clears artificial bandwidth limit + * + * @generated from field: int64 subscriber_bandwidth = 6; + */ + value: bigint; + case: "subscriberBandwidth"; + } | { + /** + * disconnect signal on resume + * + * @generated from field: bool disconnect_signal_on_resume = 7; + */ + value: boolean; + case: "disconnectSignalOnResume"; + } | { + /** + * disconnect signal on resume before sending any messages from server + * + * @generated from field: bool disconnect_signal_on_resume_no_messages = 8; + */ + value: boolean; + case: "disconnectSignalOnResumeNoMessages"; + } | { + /** + * full reconnect leave request + * + * @generated from field: bool leave_request_full_reconnect = 9; + */ + value: boolean; + case: "leaveRequestFullReconnect"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SimulateScenario"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "speaker_update", kind: "scalar", T: 5 /* ScalarType.INT32 */, oneof: "scenario" }, + { no: 2, name: "node_failure", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + { no: 3, name: "migration", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + { no: 4, name: "server_leave", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + { no: 5, name: "switch_candidate_protocol", kind: "enum", T: proto3.getEnumType(CandidateProtocol), oneof: "scenario" }, + { no: 6, name: "subscriber_bandwidth", kind: "scalar", T: 3 /* ScalarType.INT64 */, oneof: "scenario" }, + { no: 7, name: "disconnect_signal_on_resume", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + { no: 8, name: "disconnect_signal_on_resume_no_messages", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + { no: 9, name: "leave_request_full_reconnect", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "scenario" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SimulateScenario { + return new SimulateScenario().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SimulateScenario { + return new SimulateScenario().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SimulateScenario { + return new SimulateScenario().fromJsonString(jsonString, options); + } + + static equals(a: SimulateScenario | PlainMessage | undefined, b: SimulateScenario | PlainMessage | undefined): boolean { + return proto3.util.equals(SimulateScenario, a, b); + } +} + +/** + * @generated from message livekit.Ping + */ +export class Ping extends Message { + /** + * @generated from field: int64 timestamp = 1; + */ + timestamp = protoInt64.zero; + + /** + * rtt in milliseconds calculated by client + * + * @generated from field: int64 rtt = 2; + */ + rtt = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Ping"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "rtt", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Ping { + return new Ping().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Ping { + return new Ping().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Ping { + return new Ping().fromJsonString(jsonString, options); + } + + static equals(a: Ping | PlainMessage | undefined, b: Ping | PlainMessage | undefined): boolean { + return proto3.util.equals(Ping, a, b); + } +} + +/** + * @generated from message livekit.Pong + */ +export class Pong extends Message { + /** + * timestamp field of last received ping request + * + * @generated from field: int64 last_ping_timestamp = 1; + */ + lastPingTimestamp = protoInt64.zero; + + /** + * @generated from field: int64 timestamp = 2; + */ + timestamp = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.Pong"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "last_ping_timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 2, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Pong { + return new Pong().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Pong { + return new Pong().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Pong { + return new Pong().fromJsonString(jsonString, options); + } + + static equals(a: Pong | PlainMessage | undefined, b: Pong | PlainMessage | undefined): boolean { + return proto3.util.equals(Pong, a, b); + } +} + +/** + * @generated from message livekit.RegionSettings + */ +export class RegionSettings extends Message { + /** + * @generated from field: repeated livekit.RegionInfo regions = 1; + */ + regions: RegionInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RegionSettings"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "regions", kind: "message", T: RegionInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RegionSettings { + return new RegionSettings().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RegionSettings { + return new RegionSettings().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RegionSettings { + return new RegionSettings().fromJsonString(jsonString, options); + } + + static equals(a: RegionSettings | PlainMessage | undefined, b: RegionSettings | PlainMessage | undefined): boolean { + return proto3.util.equals(RegionSettings, a, b); + } +} + +/** + * @generated from message livekit.RegionInfo + */ +export class RegionInfo extends Message { + /** + * @generated from field: string region = 1; + */ + region = ""; + + /** + * @generated from field: string url = 2; + */ + url = ""; + + /** + * @generated from field: int64 distance = 3; + */ + distance = protoInt64.zero; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RegionInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "distance", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RegionInfo { + return new RegionInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RegionInfo { + return new RegionInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RegionInfo { + return new RegionInfo().fromJsonString(jsonString, options); + } + + static equals(a: RegionInfo | PlainMessage | undefined, b: RegionInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(RegionInfo, a, b); + } +} + +/** + * @generated from message livekit.SubscriptionResponse + */ +export class SubscriptionResponse extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + /** + * @generated from field: livekit.SubscriptionError err = 2; + */ + err = SubscriptionError.SE_UNKNOWN; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SubscriptionResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "err", kind: "enum", T: proto3.getEnumType(SubscriptionError) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscriptionResponse { + return new SubscriptionResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscriptionResponse { + return new SubscriptionResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscriptionResponse { + return new SubscriptionResponse().fromJsonString(jsonString, options); + } + + static equals(a: SubscriptionResponse | PlainMessage | undefined, b: SubscriptionResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscriptionResponse, a, b); + } +} + +/** + * @generated from message livekit.RequestResponse + */ +export class RequestResponse extends Message { + /** + * @generated from field: uint32 request_id = 1; + */ + requestId = 0; + + /** + * @generated from field: livekit.RequestResponse.Reason reason = 2; + */ + reason = RequestResponse_Reason.OK; + + /** + * @generated from field: string message = 3; + */ + message = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.RequestResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "request_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "reason", kind: "enum", T: proto3.getEnumType(RequestResponse_Reason) }, + { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): RequestResponse { + return new RequestResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): RequestResponse { + return new RequestResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): RequestResponse { + return new RequestResponse().fromJsonString(jsonString, options); + } + + static equals(a: RequestResponse | PlainMessage | undefined, b: RequestResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(RequestResponse, a, b); + } +} + +/** + * @generated from enum livekit.RequestResponse.Reason + */ +export enum RequestResponse_Reason { + /** + * @generated from enum value: OK = 0; + */ + OK = 0, + + /** + * @generated from enum value: NOT_FOUND = 1; + */ + NOT_FOUND = 1, + + /** + * @generated from enum value: NOT_ALLOWED = 2; + */ + NOT_ALLOWED = 2, + + /** + * @generated from enum value: LIMIT_EXCEEDED = 3; + */ + LIMIT_EXCEEDED = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(RequestResponse_Reason) +proto3.util.setEnumType(RequestResponse_Reason, "livekit.RequestResponse.Reason", [ + { no: 0, name: "OK" }, + { no: 1, name: "NOT_FOUND" }, + { no: 2, name: "NOT_ALLOWED" }, + { no: 3, name: "LIMIT_EXCEEDED" }, +]); + +/** + * @generated from message livekit.TrackSubscribed + */ +export class TrackSubscribed extends Message { + /** + * @generated from field: string track_sid = 1; + */ + trackSid = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TrackSubscribed"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TrackSubscribed { + return new TrackSubscribed().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TrackSubscribed { + return new TrackSubscribed().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TrackSubscribed { + return new TrackSubscribed().fromJsonString(jsonString, options); + } + + static equals(a: TrackSubscribed | PlainMessage | undefined, b: TrackSubscribed | PlainMessage | undefined): boolean { + return proto3.util.equals(TrackSubscribed, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_sip_pb.ts b/packages/javascript/src/gen/livekit_sip_pb.ts new file mode 100644 index 00000000..1c77efd4 --- /dev/null +++ b/packages/javascript/src/gen/livekit_sip_pb.ts @@ -0,0 +1,2026 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_sip.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Duration, Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { DisconnectReason } from "./livekit_models_pb.js"; + +/** + * @generated from enum livekit.SIPTransport + */ +export enum SIPTransport { + /** + * @generated from enum value: SIP_TRANSPORT_AUTO = 0; + */ + SIP_TRANSPORT_AUTO = 0, + + /** + * @generated from enum value: SIP_TRANSPORT_UDP = 1; + */ + SIP_TRANSPORT_UDP = 1, + + /** + * @generated from enum value: SIP_TRANSPORT_TCP = 2; + */ + SIP_TRANSPORT_TCP = 2, + + /** + * @generated from enum value: SIP_TRANSPORT_TLS = 3; + */ + SIP_TRANSPORT_TLS = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(SIPTransport) +proto3.util.setEnumType(SIPTransport, "livekit.SIPTransport", [ + { no: 0, name: "SIP_TRANSPORT_AUTO" }, + { no: 1, name: "SIP_TRANSPORT_UDP" }, + { no: 2, name: "SIP_TRANSPORT_TCP" }, + { no: 3, name: "SIP_TRANSPORT_TLS" }, +]); + +/** + * @generated from enum livekit.SIPCallStatus + */ +export enum SIPCallStatus { + /** + * Incoming call is being handled by the SIP service. The SIP participant hasn't joined a LiveKit room yet + * + * @generated from enum value: SCS_CALL_INCOMING = 0; + */ + SCS_CALL_INCOMING = 0, + + /** + * SIP participant for outgoing call has been created. The SIP outgoing call is being established + * + * @generated from enum value: SCS_PARTICIPANT_JOINED = 1; + */ + SCS_PARTICIPANT_JOINED = 1, + + /** + * Call is ongoing. SIP participant is active in the LiveKit room + * + * @generated from enum value: SCS_ACTIVE = 2; + */ + SCS_ACTIVE = 2, + + /** + * Call has ended + * + * @generated from enum value: SCS_DISCONNECTED = 3; + */ + SCS_DISCONNECTED = 3, + + /** + * Call has ended or never succeeded because of an error + * + * @generated from enum value: SCS_ERROR = 4; + */ + SCS_ERROR = 4, +} +// Retrieve enum metadata with: proto3.getEnumType(SIPCallStatus) +proto3.util.setEnumType(SIPCallStatus, "livekit.SIPCallStatus", [ + { no: 0, name: "SCS_CALL_INCOMING" }, + { no: 1, name: "SCS_PARTICIPANT_JOINED" }, + { no: 2, name: "SCS_ACTIVE" }, + { no: 3, name: "SCS_DISCONNECTED" }, + { no: 4, name: "SCS_ERROR" }, +]); + +/** + * @generated from message livekit.CreateSIPTrunkRequest + * @deprecated + */ +export class CreateSIPTrunkRequest extends Message { + /** + * CIDR or IPs that traffic is accepted from + * An empty list means all inbound traffic is accepted. + * + * @generated from field: repeated string inbound_addresses = 1; + */ + inboundAddresses: string[] = []; + + /** + * IP that SIP INVITE is sent too + * + * @generated from field: string outbound_address = 2; + */ + outboundAddress = ""; + + /** + * Number used to make outbound calls + * + * @generated from field: string outbound_number = 3; + */ + outboundNumber = ""; + + /** + * @generated from field: repeated string inbound_numbers_regex = 4 [deprecated = true]; + * @deprecated + */ + inboundNumbersRegex: string[] = []; + + /** + * Accepted `To` values. This Trunk will only accept a call made to + * these numbers. This allows you to have distinct Trunks for different phone + * numbers at the same provider. + * + * @generated from field: repeated string inbound_numbers = 9; + */ + inboundNumbers: string[] = []; + + /** + * Username and password used to authenticate inbound and outbound SIP invites + * May be empty to have no Authentication + * + * @generated from field: string inbound_username = 5; + */ + inboundUsername = ""; + + /** + * @generated from field: string inbound_password = 6; + */ + inboundPassword = ""; + + /** + * @generated from field: string outbound_username = 7; + */ + outboundUsername = ""; + + /** + * @generated from field: string outbound_password = 8; + */ + outboundPassword = ""; + + /** + * Optional human-readable name for the Trunk. + * + * @generated from field: string name = 10; + */ + name = ""; + + /** + * Optional user-defined metadata for the Trunk. + * + * @generated from field: string metadata = 11; + */ + metadata = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateSIPTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "inbound_addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 2, name: "outbound_address", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "outbound_number", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "inbound_numbers_regex", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 9, name: "inbound_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 5, name: "inbound_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "inbound_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "outbound_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "outbound_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 10, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateSIPTrunkRequest { + return new CreateSIPTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateSIPTrunkRequest { + return new CreateSIPTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateSIPTrunkRequest { + return new CreateSIPTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateSIPTrunkRequest | PlainMessage | undefined, b: CreateSIPTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateSIPTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPTrunkInfo + * @deprecated + */ +export class SIPTrunkInfo extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + /** + * @generated from field: livekit.SIPTrunkInfo.TrunkKind kind = 14; + */ + kind = SIPTrunkInfo_TrunkKind.TRUNK_LEGACY; + + /** + * CIDR or IPs that traffic is accepted from + * An empty list means all inbound traffic is accepted. + * + * @generated from field: repeated string inbound_addresses = 2; + */ + inboundAddresses: string[] = []; + + /** + * IP that SIP INVITE is sent too + * + * @generated from field: string outbound_address = 3; + */ + outboundAddress = ""; + + /** + * Number used to make outbound calls + * + * @generated from field: string outbound_number = 4; + */ + outboundNumber = ""; + + /** + * Transport used for inbound and outbound calls. + * + * @generated from field: livekit.SIPTransport transport = 13; + */ + transport = SIPTransport.SIP_TRANSPORT_AUTO; + + /** + * @generated from field: repeated string inbound_numbers_regex = 5 [deprecated = true]; + * @deprecated + */ + inboundNumbersRegex: string[] = []; + + /** + * Accepted `To` values. This Trunk will only accept a call made to + * these numbers. This allows you to have distinct Trunks for different phone + * numbers at the same provider. + * + * @generated from field: repeated string inbound_numbers = 10; + */ + inboundNumbers: string[] = []; + + /** + * Username and password used to authenticate inbound and outbound SIP invites + * May be empty to have no Authentication + * + * @generated from field: string inbound_username = 6; + */ + inboundUsername = ""; + + /** + * @generated from field: string inbound_password = 7; + */ + inboundPassword = ""; + + /** + * @generated from field: string outbound_username = 8; + */ + outboundUsername = ""; + + /** + * @generated from field: string outbound_password = 9; + */ + outboundPassword = ""; + + /** + * Human-readable name for the Trunk. + * + * @generated from field: string name = 11; + */ + name = ""; + + /** + * User-defined metadata for the Trunk. + * + * @generated from field: string metadata = 12; + */ + metadata = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPTrunkInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 14, name: "kind", kind: "enum", T: proto3.getEnumType(SIPTrunkInfo_TrunkKind) }, + { no: 2, name: "inbound_addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 3, name: "outbound_address", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "outbound_number", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 13, name: "transport", kind: "enum", T: proto3.getEnumType(SIPTransport) }, + { no: 5, name: "inbound_numbers_regex", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 10, name: "inbound_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 6, name: "inbound_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "inbound_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "outbound_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "outbound_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 11, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 12, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPTrunkInfo { + return new SIPTrunkInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPTrunkInfo { + return new SIPTrunkInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPTrunkInfo { + return new SIPTrunkInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPTrunkInfo | PlainMessage | undefined, b: SIPTrunkInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPTrunkInfo, a, b); + } +} + +/** + * @generated from enum livekit.SIPTrunkInfo.TrunkKind + */ +export enum SIPTrunkInfo_TrunkKind { + /** + * @generated from enum value: TRUNK_LEGACY = 0; + */ + TRUNK_LEGACY = 0, + + /** + * @generated from enum value: TRUNK_INBOUND = 1; + */ + TRUNK_INBOUND = 1, + + /** + * @generated from enum value: TRUNK_OUTBOUND = 2; + */ + TRUNK_OUTBOUND = 2, +} +// Retrieve enum metadata with: proto3.getEnumType(SIPTrunkInfo_TrunkKind) +proto3.util.setEnumType(SIPTrunkInfo_TrunkKind, "livekit.SIPTrunkInfo.TrunkKind", [ + { no: 0, name: "TRUNK_LEGACY" }, + { no: 1, name: "TRUNK_INBOUND" }, + { no: 2, name: "TRUNK_OUTBOUND" }, +]); + +/** + * @generated from message livekit.CreateSIPInboundTrunkRequest + */ +export class CreateSIPInboundTrunkRequest extends Message { + /** + * Trunk ID is ignored + * + * @generated from field: livekit.SIPInboundTrunkInfo trunk = 1; + */ + trunk?: SIPInboundTrunkInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateSIPInboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "trunk", kind: "message", T: SIPInboundTrunkInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateSIPInboundTrunkRequest { + return new CreateSIPInboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateSIPInboundTrunkRequest { + return new CreateSIPInboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateSIPInboundTrunkRequest { + return new CreateSIPInboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateSIPInboundTrunkRequest | PlainMessage | undefined, b: CreateSIPInboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateSIPInboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPInboundTrunkInfo + */ +export class SIPInboundTrunkInfo extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + /** + * Human-readable name for the Trunk. + * + * @generated from field: string name = 2; + */ + name = ""; + + /** + * User-defined metadata for the Trunk. + * + * @generated from field: string metadata = 3; + */ + metadata = ""; + + /** + * Numbers associated with LiveKit SIP. The Trunk will only accept calls made to these numbers. + * Creating multiple Trunks with different phone numbers allows having different rules for a single provider. + * + * @generated from field: repeated string numbers = 4; + */ + numbers: string[] = []; + + /** + * CIDR or IPs that traffic is accepted from. + * An empty list means all inbound traffic is accepted. + * + * @generated from field: repeated string allowed_addresses = 5; + */ + allowedAddresses: string[] = []; + + /** + * Numbers that are allowed to make calls to this Trunk. + * An empty list means calls from any phone number is accepted. + * + * @generated from field: repeated string allowed_numbers = 6; + */ + allowedNumbers: string[] = []; + + /** + * Username and password used to authenticate inbound SIP invites. + * May be empty to have no authentication. + * + * @generated from field: string auth_username = 7; + */ + authUsername = ""; + + /** + * @generated from field: string auth_password = 8; + */ + authPassword = ""; + + /** + * Include these SIP X-* headers in 200 OK responses. + * + * @generated from field: map headers = 9; + */ + headers: { [key: string]: string } = {}; + + /** + * Map SIP X-* headers from INVITE to SIP participant attributes. + * + * @generated from field: map headers_to_attributes = 10; + */ + headersToAttributes: { [key: string]: string } = {}; + + /** + * Max time for the caller to wait for track subscription. + * + * @generated from field: google.protobuf.Duration ringing_timeout = 11; + */ + ringingTimeout?: Duration; + + /** + * Max call duration. + * + * @generated from field: google.protobuf.Duration max_call_duration = 12; + */ + maxCallDuration?: Duration; + + /** + * @generated from field: bool krisp_enabled = 13; + */ + krispEnabled = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPInboundTrunkInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 5, name: "allowed_addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 6, name: "allowed_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 7, name: "auth_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "auth_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "headers", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 10, name: "headers_to_attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 11, name: "ringing_timeout", kind: "message", T: Duration }, + { no: 12, name: "max_call_duration", kind: "message", T: Duration }, + { no: 13, name: "krisp_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPInboundTrunkInfo { + return new SIPInboundTrunkInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPInboundTrunkInfo { + return new SIPInboundTrunkInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPInboundTrunkInfo { + return new SIPInboundTrunkInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPInboundTrunkInfo | PlainMessage | undefined, b: SIPInboundTrunkInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPInboundTrunkInfo, a, b); + } +} + +/** + * @generated from message livekit.CreateSIPOutboundTrunkRequest + */ +export class CreateSIPOutboundTrunkRequest extends Message { + /** + * Trunk ID is ignored + * + * @generated from field: livekit.SIPOutboundTrunkInfo trunk = 1; + */ + trunk?: SIPOutboundTrunkInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateSIPOutboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "trunk", kind: "message", T: SIPOutboundTrunkInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateSIPOutboundTrunkRequest { + return new CreateSIPOutboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateSIPOutboundTrunkRequest { + return new CreateSIPOutboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateSIPOutboundTrunkRequest { + return new CreateSIPOutboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateSIPOutboundTrunkRequest | PlainMessage | undefined, b: CreateSIPOutboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateSIPOutboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPOutboundTrunkInfo + */ +export class SIPOutboundTrunkInfo extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + /** + * Human-readable name for the Trunk. + * + * @generated from field: string name = 2; + */ + name = ""; + + /** + * User-defined metadata for the Trunk. + * + * @generated from field: string metadata = 3; + */ + metadata = ""; + + /** + * Hostname or IP that SIP INVITE is sent too. + * Note that this is not a SIP URI and should not contain the 'sip:' protocol prefix. + * + * @generated from field: string address = 4; + */ + address = ""; + + /** + * SIP Transport used for outbound call. + * + * @generated from field: livekit.SIPTransport transport = 5; + */ + transport = SIPTransport.SIP_TRANSPORT_AUTO; + + /** + * Numbers used to make the calls. Random one from this list will be selected. + * + * @generated from field: repeated string numbers = 6; + */ + numbers: string[] = []; + + /** + * Username and password used to authenticate with SIP server. + * May be empty to have no authentication. + * + * @generated from field: string auth_username = 7; + */ + authUsername = ""; + + /** + * @generated from field: string auth_password = 8; + */ + authPassword = ""; + + /** + * Include these SIP X-* headers in INVITE request. + * These headers are sent as-is and may help identify this call as coming from LiveKit for the other SIP endpoint. + * + * @generated from field: map headers = 9; + */ + headers: { [key: string]: string } = {}; + + /** + * Map SIP X-* headers from 200 OK to SIP participant attributes. + * Keys are the names of X-* headers and values are the names of attributes they will be mapped to. + * + * @generated from field: map headers_to_attributes = 10; + */ + headersToAttributes: { [key: string]: string } = {}; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPOutboundTrunkInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "transport", kind: "enum", T: proto3.getEnumType(SIPTransport) }, + { no: 6, name: "numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 7, name: "auth_username", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "auth_password", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "headers", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 10, name: "headers_to_attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPOutboundTrunkInfo { + return new SIPOutboundTrunkInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPOutboundTrunkInfo { + return new SIPOutboundTrunkInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPOutboundTrunkInfo { + return new SIPOutboundTrunkInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPOutboundTrunkInfo | PlainMessage | undefined, b: SIPOutboundTrunkInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPOutboundTrunkInfo, a, b); + } +} + +/** + * @generated from message livekit.GetSIPInboundTrunkRequest + */ +export class GetSIPInboundTrunkRequest extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.GetSIPInboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetSIPInboundTrunkRequest { + return new GetSIPInboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetSIPInboundTrunkRequest { + return new GetSIPInboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetSIPInboundTrunkRequest { + return new GetSIPInboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetSIPInboundTrunkRequest | PlainMessage | undefined, b: GetSIPInboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetSIPInboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.GetSIPInboundTrunkResponse + */ +export class GetSIPInboundTrunkResponse extends Message { + /** + * @generated from field: livekit.SIPInboundTrunkInfo trunk = 1; + */ + trunk?: SIPInboundTrunkInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.GetSIPInboundTrunkResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "trunk", kind: "message", T: SIPInboundTrunkInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetSIPInboundTrunkResponse { + return new GetSIPInboundTrunkResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetSIPInboundTrunkResponse { + return new GetSIPInboundTrunkResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetSIPInboundTrunkResponse { + return new GetSIPInboundTrunkResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetSIPInboundTrunkResponse | PlainMessage | undefined, b: GetSIPInboundTrunkResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetSIPInboundTrunkResponse, a, b); + } +} + +/** + * @generated from message livekit.GetSIPOutboundTrunkRequest + */ +export class GetSIPOutboundTrunkRequest extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.GetSIPOutboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetSIPOutboundTrunkRequest { + return new GetSIPOutboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetSIPOutboundTrunkRequest { + return new GetSIPOutboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetSIPOutboundTrunkRequest { + return new GetSIPOutboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetSIPOutboundTrunkRequest | PlainMessage | undefined, b: GetSIPOutboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetSIPOutboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.GetSIPOutboundTrunkResponse + */ +export class GetSIPOutboundTrunkResponse extends Message { + /** + * @generated from field: livekit.SIPOutboundTrunkInfo trunk = 1; + */ + trunk?: SIPOutboundTrunkInfo; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.GetSIPOutboundTrunkResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "trunk", kind: "message", T: SIPOutboundTrunkInfo }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetSIPOutboundTrunkResponse { + return new GetSIPOutboundTrunkResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetSIPOutboundTrunkResponse { + return new GetSIPOutboundTrunkResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetSIPOutboundTrunkResponse { + return new GetSIPOutboundTrunkResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetSIPOutboundTrunkResponse | PlainMessage | undefined, b: GetSIPOutboundTrunkResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetSIPOutboundTrunkResponse, a, b); + } +} + +/** + * @generated from message livekit.ListSIPTrunkRequest + * @deprecated + */ +export class ListSIPTrunkRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPTrunkRequest { + return new ListSIPTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPTrunkRequest { + return new ListSIPTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPTrunkRequest { + return new ListSIPTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPTrunkRequest | PlainMessage | undefined, b: ListSIPTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.ListSIPTrunkResponse + * @deprecated + */ +export class ListSIPTrunkResponse extends Message { + /** + * @generated from field: repeated livekit.SIPTrunkInfo items = 1; + */ + items: SIPTrunkInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPTrunkResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: SIPTrunkInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPTrunkResponse { + return new ListSIPTrunkResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPTrunkResponse { + return new ListSIPTrunkResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPTrunkResponse { + return new ListSIPTrunkResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPTrunkResponse | PlainMessage | undefined, b: ListSIPTrunkResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPTrunkResponse, a, b); + } +} + +/** + * @generated from message livekit.ListSIPInboundTrunkRequest + */ +export class ListSIPInboundTrunkRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPInboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPInboundTrunkRequest { + return new ListSIPInboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPInboundTrunkRequest { + return new ListSIPInboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPInboundTrunkRequest { + return new ListSIPInboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPInboundTrunkRequest | PlainMessage | undefined, b: ListSIPInboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPInboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.ListSIPInboundTrunkResponse + */ +export class ListSIPInboundTrunkResponse extends Message { + /** + * @generated from field: repeated livekit.SIPInboundTrunkInfo items = 1; + */ + items: SIPInboundTrunkInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPInboundTrunkResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: SIPInboundTrunkInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPInboundTrunkResponse { + return new ListSIPInboundTrunkResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPInboundTrunkResponse { + return new ListSIPInboundTrunkResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPInboundTrunkResponse { + return new ListSIPInboundTrunkResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPInboundTrunkResponse | PlainMessage | undefined, b: ListSIPInboundTrunkResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPInboundTrunkResponse, a, b); + } +} + +/** + * @generated from message livekit.ListSIPOutboundTrunkRequest + */ +export class ListSIPOutboundTrunkRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPOutboundTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPOutboundTrunkRequest { + return new ListSIPOutboundTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPOutboundTrunkRequest { + return new ListSIPOutboundTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPOutboundTrunkRequest { + return new ListSIPOutboundTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPOutboundTrunkRequest | PlainMessage | undefined, b: ListSIPOutboundTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPOutboundTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.ListSIPOutboundTrunkResponse + */ +export class ListSIPOutboundTrunkResponse extends Message { + /** + * @generated from field: repeated livekit.SIPOutboundTrunkInfo items = 1; + */ + items: SIPOutboundTrunkInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPOutboundTrunkResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: SIPOutboundTrunkInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPOutboundTrunkResponse { + return new ListSIPOutboundTrunkResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPOutboundTrunkResponse { + return new ListSIPOutboundTrunkResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPOutboundTrunkResponse { + return new ListSIPOutboundTrunkResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPOutboundTrunkResponse | PlainMessage | undefined, b: ListSIPOutboundTrunkResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPOutboundTrunkResponse, a, b); + } +} + +/** + * @generated from message livekit.DeleteSIPTrunkRequest + */ +export class DeleteSIPTrunkRequest extends Message { + /** + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteSIPTrunkRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteSIPTrunkRequest { + return new DeleteSIPTrunkRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteSIPTrunkRequest { + return new DeleteSIPTrunkRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteSIPTrunkRequest { + return new DeleteSIPTrunkRequest().fromJsonString(jsonString, options); + } + + static equals(a: DeleteSIPTrunkRequest | PlainMessage | undefined, b: DeleteSIPTrunkRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteSIPTrunkRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPDispatchRuleDirect + */ +export class SIPDispatchRuleDirect extends Message { + /** + * What room should call be directed into + * + * @generated from field: string room_name = 1; + */ + roomName = ""; + + /** + * Optional pin required to enter room + * + * @generated from field: string pin = 2; + */ + pin = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPDispatchRuleDirect"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPDispatchRuleDirect { + return new SIPDispatchRuleDirect().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPDispatchRuleDirect { + return new SIPDispatchRuleDirect().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPDispatchRuleDirect { + return new SIPDispatchRuleDirect().fromJsonString(jsonString, options); + } + + static equals(a: SIPDispatchRuleDirect | PlainMessage | undefined, b: SIPDispatchRuleDirect | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPDispatchRuleDirect, a, b); + } +} + +/** + * @generated from message livekit.SIPDispatchRuleIndividual + */ +export class SIPDispatchRuleIndividual extends Message { + /** + * Prefix used on new room name + * + * @generated from field: string room_prefix = 1; + */ + roomPrefix = ""; + + /** + * Optional pin required to enter room + * + * @generated from field: string pin = 2; + */ + pin = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPDispatchRuleIndividual"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPDispatchRuleIndividual { + return new SIPDispatchRuleIndividual().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPDispatchRuleIndividual { + return new SIPDispatchRuleIndividual().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPDispatchRuleIndividual { + return new SIPDispatchRuleIndividual().fromJsonString(jsonString, options); + } + + static equals(a: SIPDispatchRuleIndividual | PlainMessage | undefined, b: SIPDispatchRuleIndividual | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPDispatchRuleIndividual, a, b); + } +} + +/** + * @generated from message livekit.SIPDispatchRuleCallee + */ +export class SIPDispatchRuleCallee extends Message { + /** + * Prefix used on new room name + * + * @generated from field: string room_prefix = 1; + */ + roomPrefix = ""; + + /** + * Optional pin required to enter room + * + * @generated from field: string pin = 2; + */ + pin = ""; + + /** + * Optionally append random suffix + * + * @generated from field: bool randomize = 3; + */ + randomize = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPDispatchRuleCallee"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "room_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "randomize", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPDispatchRuleCallee { + return new SIPDispatchRuleCallee().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPDispatchRuleCallee { + return new SIPDispatchRuleCallee().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPDispatchRuleCallee { + return new SIPDispatchRuleCallee().fromJsonString(jsonString, options); + } + + static equals(a: SIPDispatchRuleCallee | PlainMessage | undefined, b: SIPDispatchRuleCallee | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPDispatchRuleCallee, a, b); + } +} + +/** + * @generated from message livekit.SIPDispatchRule + */ +export class SIPDispatchRule extends Message { + /** + * @generated from oneof livekit.SIPDispatchRule.rule + */ + rule: { + /** + * SIPDispatchRuleDirect is a `SIP Dispatch Rule` that puts a user directly into a room + * This places users into an existing room. Optionally you can require a pin before a user can + * enter the room + * + * @generated from field: livekit.SIPDispatchRuleDirect dispatch_rule_direct = 1; + */ + value: SIPDispatchRuleDirect; + case: "dispatchRuleDirect"; + } | { + /** + * SIPDispatchRuleIndividual is a `SIP Dispatch Rule` that creates a new room for each caller. + * + * @generated from field: livekit.SIPDispatchRuleIndividual dispatch_rule_individual = 2; + */ + value: SIPDispatchRuleIndividual; + case: "dispatchRuleIndividual"; + } | { + /** + * SIPDispatchRuleCallee is a `SIP Dispatch Rule` that creates a new room for each callee. + * + * @generated from field: livekit.SIPDispatchRuleCallee dispatch_rule_callee = 3; + */ + value: SIPDispatchRuleCallee; + case: "dispatchRuleCallee"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPDispatchRule"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "dispatch_rule_direct", kind: "message", T: SIPDispatchRuleDirect, oneof: "rule" }, + { no: 2, name: "dispatch_rule_individual", kind: "message", T: SIPDispatchRuleIndividual, oneof: "rule" }, + { no: 3, name: "dispatch_rule_callee", kind: "message", T: SIPDispatchRuleCallee, oneof: "rule" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPDispatchRule { + return new SIPDispatchRule().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPDispatchRule { + return new SIPDispatchRule().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPDispatchRule { + return new SIPDispatchRule().fromJsonString(jsonString, options); + } + + static equals(a: SIPDispatchRule | PlainMessage | undefined, b: SIPDispatchRule | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPDispatchRule, a, b); + } +} + +/** + * @generated from message livekit.CreateSIPDispatchRuleRequest + */ +export class CreateSIPDispatchRuleRequest extends Message { + /** + * @generated from field: livekit.SIPDispatchRule rule = 1; + */ + rule?: SIPDispatchRule; + + /** + * What trunks are accepted for this dispatch rule + * If empty all trunks will match this dispatch rule + * + * @generated from field: repeated string trunk_ids = 2; + */ + trunkIds: string[] = []; + + /** + * By default the From value (Phone number) is used for participant name/identity and added to attributes. + * If true, a random value for identity will be used and numbers will be omitted from attributes. + * + * @generated from field: bool hide_phone_number = 3; + */ + hidePhoneNumber = false; + + /** + * Dispatch Rule will only accept a call made to these numbers (if set). + * + * @generated from field: repeated string inbound_numbers = 6; + */ + inboundNumbers: string[] = []; + + /** + * Optional human-readable name for the Dispatch Rule. + * + * @generated from field: string name = 4; + */ + name = ""; + + /** + * User-defined metadata for the Dispatch Rule. + * Participants created by this rule will inherit this metadata. + * + * @generated from field: string metadata = 5; + */ + metadata = ""; + + /** + * User-defined attributes for the Dispatch Rule. + * Participants created by this rule will inherit these attributes. + * + * @generated from field: map attributes = 7; + */ + attributes: { [key: string]: string } = {}; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateSIPDispatchRuleRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "rule", kind: "message", T: SIPDispatchRule }, + { no: 2, name: "trunk_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 3, name: "hide_phone_number", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 6, name: "inbound_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateSIPDispatchRuleRequest { + return new CreateSIPDispatchRuleRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateSIPDispatchRuleRequest { + return new CreateSIPDispatchRuleRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateSIPDispatchRuleRequest { + return new CreateSIPDispatchRuleRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateSIPDispatchRuleRequest | PlainMessage | undefined, b: CreateSIPDispatchRuleRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateSIPDispatchRuleRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPDispatchRuleInfo + */ +export class SIPDispatchRuleInfo extends Message { + /** + * @generated from field: string sip_dispatch_rule_id = 1; + */ + sipDispatchRuleId = ""; + + /** + * @generated from field: livekit.SIPDispatchRule rule = 2; + */ + rule?: SIPDispatchRule; + + /** + * @generated from field: repeated string trunk_ids = 3; + */ + trunkIds: string[] = []; + + /** + * @generated from field: bool hide_phone_number = 4; + */ + hidePhoneNumber = false; + + /** + * Dispatch Rule will only accept a call made to these numbers (if set). + * + * @generated from field: repeated string inbound_numbers = 7; + */ + inboundNumbers: string[] = []; + + /** + * Human-readable name for the Dispatch Rule. + * + * @generated from field: string name = 5; + */ + name = ""; + + /** + * User-defined metadata for the Dispatch Rule. + * Participants created by this rule will inherit this metadata. + * + * @generated from field: string metadata = 6; + */ + metadata = ""; + + /** + * User-defined attributes for the Dispatch Rule. + * Participants created by this rule will inherit these attributes. + * + * @generated from field: map attributes = 8; + */ + attributes: { [key: string]: string } = {}; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPDispatchRuleInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_dispatch_rule_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "rule", kind: "message", T: SIPDispatchRule }, + { no: 3, name: "trunk_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 4, name: "hide_phone_number", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 7, name: "inbound_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPDispatchRuleInfo { + return new SIPDispatchRuleInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPDispatchRuleInfo { + return new SIPDispatchRuleInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPDispatchRuleInfo { + return new SIPDispatchRuleInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPDispatchRuleInfo | PlainMessage | undefined, b: SIPDispatchRuleInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPDispatchRuleInfo, a, b); + } +} + +/** + * @generated from message livekit.ListSIPDispatchRuleRequest + */ +export class ListSIPDispatchRuleRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPDispatchRuleRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPDispatchRuleRequest { + return new ListSIPDispatchRuleRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPDispatchRuleRequest { + return new ListSIPDispatchRuleRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPDispatchRuleRequest { + return new ListSIPDispatchRuleRequest().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPDispatchRuleRequest | PlainMessage | undefined, b: ListSIPDispatchRuleRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPDispatchRuleRequest, a, b); + } +} + +/** + * @generated from message livekit.ListSIPDispatchRuleResponse + */ +export class ListSIPDispatchRuleResponse extends Message { + /** + * @generated from field: repeated livekit.SIPDispatchRuleInfo items = 1; + */ + items: SIPDispatchRuleInfo[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.ListSIPDispatchRuleResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "items", kind: "message", T: SIPDispatchRuleInfo, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ListSIPDispatchRuleResponse { + return new ListSIPDispatchRuleResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ListSIPDispatchRuleResponse { + return new ListSIPDispatchRuleResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ListSIPDispatchRuleResponse { + return new ListSIPDispatchRuleResponse().fromJsonString(jsonString, options); + } + + static equals(a: ListSIPDispatchRuleResponse | PlainMessage | undefined, b: ListSIPDispatchRuleResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(ListSIPDispatchRuleResponse, a, b); + } +} + +/** + * @generated from message livekit.DeleteSIPDispatchRuleRequest + */ +export class DeleteSIPDispatchRuleRequest extends Message { + /** + * @generated from field: string sip_dispatch_rule_id = 1; + */ + sipDispatchRuleId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.DeleteSIPDispatchRuleRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_dispatch_rule_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DeleteSIPDispatchRuleRequest { + return new DeleteSIPDispatchRuleRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DeleteSIPDispatchRuleRequest { + return new DeleteSIPDispatchRuleRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DeleteSIPDispatchRuleRequest { + return new DeleteSIPDispatchRuleRequest().fromJsonString(jsonString, options); + } + + static equals(a: DeleteSIPDispatchRuleRequest | PlainMessage | undefined, b: DeleteSIPDispatchRuleRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(DeleteSIPDispatchRuleRequest, a, b); + } +} + +/** + * A SIP Participant is a singular SIP session connected to a LiveKit room via + * a SIP Trunk into a SIP DispatchRule + * + * @generated from message livekit.CreateSIPParticipantRequest + */ +export class CreateSIPParticipantRequest extends Message { + /** + * What SIP Trunk should be used to dial the user + * + * @generated from field: string sip_trunk_id = 1; + */ + sipTrunkId = ""; + + /** + * What number should be dialed via SIP + * + * @generated from field: string sip_call_to = 2; + */ + sipCallTo = ""; + + /** + * What LiveKit room should this participant be connected too + * + * @generated from field: string room_name = 3; + */ + roomName = ""; + + /** + * Optional identity of the participant in LiveKit room + * + * @generated from field: string participant_identity = 4; + */ + participantIdentity = ""; + + /** + * Optional name of the participant in LiveKit room + * + * @generated from field: string participant_name = 7; + */ + participantName = ""; + + /** + * Optional user-defined metadata. Will be attached to a created Participant in the room. + * + * @generated from field: string participant_metadata = 8; + */ + participantMetadata = ""; + + /** + * Optional user-defined attributes. Will be attached to a created Participant in the room. + * + * @generated from field: map participant_attributes = 9; + */ + participantAttributes: { [key: string]: string } = {}; + + /** + * Optionally send following DTMF digits (extension codes) when making a call. + * Character 'w' can be used to add a 0.5 sec delay. + * + * @generated from field: string dtmf = 5; + */ + dtmf = ""; + + /** + * Optionally play dialtone in the room as an audible indicator for existing participants. The `play_ringtone` option is deprectated but has the same effect. + * + * @generated from field: bool play_ringtone = 6 [deprecated = true]; + * @deprecated + */ + playRingtone = false; + + /** + * @generated from field: bool play_dialtone = 13; + */ + playDialtone = false; + + /** + * By default the From value (Phone number) is used for participant name/identity (if not set) and added to attributes. + * If true, a random value for identity will be used and numbers will be omitted from attributes. + * + * @generated from field: bool hide_phone_number = 10; + */ + hidePhoneNumber = false; + + /** + * Max time for the callee to answer the call. + * + * @generated from field: google.protobuf.Duration ringing_timeout = 11; + */ + ringingTimeout?: Duration; + + /** + * Max call duration. + * + * @generated from field: google.protobuf.Duration max_call_duration = 12; + */ + maxCallDuration?: Duration; + + /** + * Enable voice isolation for the callee. + * + * NEXT ID: 15 + * + * @generated from field: bool enable_krisp = 14; + */ + enableKrisp = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.CreateSIPParticipantRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "sip_call_to", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "participant_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 8, name: "participant_metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 9, name: "participant_attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} }, + { no: 5, name: "dtmf", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "play_ringtone", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 13, name: "play_dialtone", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 10, name: "hide_phone_number", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + { no: 11, name: "ringing_timeout", kind: "message", T: Duration }, + { no: 12, name: "max_call_duration", kind: "message", T: Duration }, + { no: 14, name: "enable_krisp", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): CreateSIPParticipantRequest { + return new CreateSIPParticipantRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): CreateSIPParticipantRequest { + return new CreateSIPParticipantRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): CreateSIPParticipantRequest { + return new CreateSIPParticipantRequest().fromJsonString(jsonString, options); + } + + static equals(a: CreateSIPParticipantRequest | PlainMessage | undefined, b: CreateSIPParticipantRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(CreateSIPParticipantRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPParticipantInfo + */ +export class SIPParticipantInfo extends Message { + /** + * @generated from field: string participant_id = 1; + */ + participantId = ""; + + /** + * @generated from field: string participant_identity = 2; + */ + participantIdentity = ""; + + /** + * @generated from field: string room_name = 3; + */ + roomName = ""; + + /** + * @generated from field: string sip_call_id = 4; + */ + sipCallId = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPParticipantInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "sip_call_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPParticipantInfo { + return new SIPParticipantInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPParticipantInfo { + return new SIPParticipantInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPParticipantInfo { + return new SIPParticipantInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPParticipantInfo | PlainMessage | undefined, b: SIPParticipantInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPParticipantInfo, a, b); + } +} + +/** + * @generated from message livekit.TransferSIPParticipantRequest + */ +export class TransferSIPParticipantRequest extends Message { + /** + * @generated from field: string participant_identity = 1; + */ + participantIdentity = ""; + + /** + * @generated from field: string room_name = 2; + */ + roomName = ""; + + /** + * @generated from field: string transfer_to = 3; + */ + transferTo = ""; + + /** + * Optionally play dialtone to the SIP participant as an audible indicator of being transferred + * + * @generated from field: bool play_dialtone = 4; + */ + playDialtone = false; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.TransferSIPParticipantRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "transfer_to", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "play_dialtone", kind: "scalar", T: 8 /* ScalarType.BOOL */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): TransferSIPParticipantRequest { + return new TransferSIPParticipantRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): TransferSIPParticipantRequest { + return new TransferSIPParticipantRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): TransferSIPParticipantRequest { + return new TransferSIPParticipantRequest().fromJsonString(jsonString, options); + } + + static equals(a: TransferSIPParticipantRequest | PlainMessage | undefined, b: TransferSIPParticipantRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(TransferSIPParticipantRequest, a, b); + } +} + +/** + * @generated from message livekit.SIPCallInfo + */ +export class SIPCallInfo extends Message { + /** + * @generated from field: string call_id = 1; + */ + callId = ""; + + /** + * @generated from field: string trunk_id = 2; + */ + trunkId = ""; + + /** + * @generated from field: string room_name = 3; + */ + roomName = ""; + + /** + * ID of the current/previous room published to + * + * @generated from field: string room_id = 4; + */ + roomId = ""; + + /** + * @generated from field: string participant_identity = 5; + */ + participantIdentity = ""; + + /** + * @generated from field: livekit.SIPUri from_uri = 6; + */ + fromUri?: SIPUri; + + /** + * @generated from field: livekit.SIPUri to_uri = 7; + */ + toUri?: SIPUri; + + /** + * @generated from field: livekit.SIPCallStatus call_status = 8; + */ + callStatus = SIPCallStatus.SCS_CALL_INCOMING; + + /** + * @generated from field: int64 created_at = 9; + */ + createdAt = protoInt64.zero; + + /** + * @generated from field: int64 started_at = 10; + */ + startedAt = protoInt64.zero; + + /** + * @generated from field: int64 ended_at = 11; + */ + endedAt = protoInt64.zero; + + /** + * @generated from field: livekit.DisconnectReason disconnect_reason = 12; + */ + disconnectReason = DisconnectReason.UNKNOWN_REASON; + + /** + * @generated from field: string error = 13; + */ + error = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPCallInfo"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "call_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "room_id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 5, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 6, name: "from_uri", kind: "message", T: SIPUri }, + { no: 7, name: "to_uri", kind: "message", T: SIPUri }, + { no: 8, name: "call_status", kind: "enum", T: proto3.getEnumType(SIPCallStatus) }, + { no: 9, name: "created_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 10, name: "started_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 11, name: "ended_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 12, name: "disconnect_reason", kind: "enum", T: proto3.getEnumType(DisconnectReason) }, + { no: 13, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPCallInfo { + return new SIPCallInfo().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPCallInfo { + return new SIPCallInfo().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPCallInfo { + return new SIPCallInfo().fromJsonString(jsonString, options); + } + + static equals(a: SIPCallInfo | PlainMessage | undefined, b: SIPCallInfo | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPCallInfo, a, b); + } +} + +/** + * @generated from message livekit.SIPUri + */ +export class SIPUri extends Message { + /** + * @generated from field: string user = 1; + */ + user = ""; + + /** + * @generated from field: string host = 2; + */ + host = ""; + + /** + * @generated from field: string ip = 3; + */ + ip = ""; + + /** + * @generated from field: uint32 port = 4; + */ + port = 0; + + /** + * @generated from field: livekit.SIPTransport transport = 5; + */ + transport = SIPTransport.SIP_TRANSPORT_AUTO; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.SIPUri"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "user", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "host", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "ip", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 4, name: "port", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 5, name: "transport", kind: "enum", T: proto3.getEnumType(SIPTransport) }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SIPUri { + return new SIPUri().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SIPUri { + return new SIPUri().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SIPUri { + return new SIPUri().fromJsonString(jsonString, options); + } + + static equals(a: SIPUri | PlainMessage | undefined, b: SIPUri | PlainMessage | undefined): boolean { + return proto3.util.equals(SIPUri, a, b); + } +} + diff --git a/packages/javascript/src/gen/livekit_webhook_pb.ts b/packages/javascript/src/gen/livekit_webhook_pb.ts new file mode 100644 index 00000000..fab54123 --- /dev/null +++ b/packages/javascript/src/gen/livekit_webhook_pb.ts @@ -0,0 +1,126 @@ +// Copyright 2023 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.0 with parameter "target=ts" +// @generated from file livekit_webhook.proto (package livekit, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, protoInt64 } from "@bufbuild/protobuf"; +import { ParticipantInfo, Room, TrackInfo } from "./livekit_models_pb.js"; +import { EgressInfo } from "./livekit_egress_pb.js"; +import { IngressInfo } from "./livekit_ingress_pb.js"; + +/** + * @generated from message livekit.WebhookEvent + */ +export class WebhookEvent extends Message { + /** + * one of room_started, room_finished, participant_joined, participant_left, + * track_published, track_unpublished, egress_started, egress_updated, egress_ended, + * ingress_started, ingress_ended + * + * @generated from field: string event = 1; + */ + event = ""; + + /** + * @generated from field: livekit.Room room = 2; + */ + room?: Room; + + /** + * set when event is participant_* or track_* + * + * @generated from field: livekit.ParticipantInfo participant = 3; + */ + participant?: ParticipantInfo; + + /** + * set when event is egress_* + * + * @generated from field: livekit.EgressInfo egress_info = 9; + */ + egressInfo?: EgressInfo; + + /** + * set when event is ingress_* + * + * @generated from field: livekit.IngressInfo ingress_info = 10; + */ + ingressInfo?: IngressInfo; + + /** + * set when event is track_* + * + * @generated from field: livekit.TrackInfo track = 8; + */ + track?: TrackInfo; + + /** + * unique event uuid + * + * @generated from field: string id = 6; + */ + id = ""; + + /** + * timestamp in seconds + * + * @generated from field: int64 created_at = 7; + */ + createdAt = protoInt64.zero; + + /** + * @generated from field: int32 num_dropped = 11; + */ + numDropped = 0; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "livekit.WebhookEvent"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "event", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "room", kind: "message", T: Room }, + { no: 3, name: "participant", kind: "message", T: ParticipantInfo }, + { no: 9, name: "egress_info", kind: "message", T: EgressInfo }, + { no: 10, name: "ingress_info", kind: "message", T: IngressInfo }, + { no: 8, name: "track", kind: "message", T: TrackInfo }, + { no: 6, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 7, name: "created_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ }, + { no: 11, name: "num_dropped", kind: "scalar", T: 5 /* ScalarType.INT32 */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): WebhookEvent { + return new WebhookEvent().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): WebhookEvent { + return new WebhookEvent().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): WebhookEvent { + return new WebhookEvent().fromJsonString(jsonString, options); + } + + static equals(a: WebhookEvent | PlainMessage | undefined, b: WebhookEvent | PlainMessage | undefined): boolean { + return proto3.util.equals(WebhookEvent, a, b); + } +} + diff --git a/packages/javascript/src/gen/version.d.ts b/packages/javascript/src/gen/version.d.ts deleted file mode 100644 index baaee2fd..00000000 --- a/packages/javascript/src/gen/version.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare const version: string; diff --git a/packages/javascript/src/gen/version.ts b/packages/javascript/src/gen/version.ts new file mode 100644 index 00000000..da3a44e3 --- /dev/null +++ b/packages/javascript/src/gen/version.ts @@ -0,0 +1,2 @@ +// Generated by genversion. +export const version = '1.27.1'; diff --git a/packages/javascript/src/index.cjs b/packages/javascript/src/index.cjs deleted file mode 100644 index b75138b5..00000000 --- a/packages/javascript/src/index.cjs +++ /dev/null @@ -1,28 +0,0 @@ -// @ts-check -const { protoInt64 } = require("@bufbuild/protobuf"); -const agentDispatch = require("./gen/livekit_agent_dispatch_pb.cjs"); -const agent = require("./gen/livekit_agent_pb.cjs"); -const egress = require("./gen/livekit_egress_pb.cjs"); -const ingress = require("./gen/livekit_ingress_pb.cjs"); -const metrics = require("./gen/livekit_metrics_pb.cjs"); -const models = require("./gen/livekit_models_pb.cjs"); -const room = require("./gen/livekit_room_pb.cjs"); -const rtc = require("./gen/livekit_rtc_pb.cjs"); -const sip = require("./gen/livekit_sip_pb.cjs"); -const webhook = require("./gen/livekit_webhook_pb.cjs"); -const version = require("./gen/version.cjs"); - -module.exports = { - protoInt64, - ...agentDispatch, - ...agent, - ...egress, - ...ingress, - ...metrics, - ...models, - ...room, - ...rtc, - ...sip, - ...webhook, - version, -} diff --git a/packages/javascript/src/index.js b/packages/javascript/src/index.js deleted file mode 100644 index e1d9ba90..00000000 --- a/packages/javascript/src/index.js +++ /dev/null @@ -1,13 +0,0 @@ -// @ts-check -export { protoInt64 } from "@bufbuild/protobuf"; -export * from "./gen/livekit_agent_dispatch_pb.js"; -export * from "./gen/livekit_agent_pb.js"; -export * from "./gen/livekit_egress_pb.js"; -export * from "./gen/livekit_ingress_pb.js"; -export * from "./gen/livekit_metrics_pb.js"; -export * from "./gen/livekit_models_pb.js"; -export * from "./gen/livekit_room_pb.js"; -export * from "./gen/livekit_rtc_pb.js"; -export * from "./gen/livekit_sip_pb.js"; -export * from "./gen/livekit_webhook_pb.js"; -export * from "./gen/version.mjs"; diff --git a/packages/javascript/src/index.d.ts b/packages/javascript/src/index.ts similarity index 100% rename from packages/javascript/src/index.d.ts rename to packages/javascript/src/index.ts diff --git a/packages/javascript/tsconfig.json b/packages/javascript/tsconfig.json new file mode 100644 index 00000000..66ecb484 --- /dev/null +++ b/packages/javascript/tsconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "target": "es2015", + "module": "es2015", + "moduleResolution": "node", + "declaration": true, + "declarationMap": true, + "skipLibCheck": true, + "sourceMap": true, + "outDir": "dist", + }, + "include": ["src/**/*.ts"], +} diff --git a/packages/javascript/tsup.config.ts b/packages/javascript/tsup.config.ts new file mode 100644 index 00000000..01533005 --- /dev/null +++ b/packages/javascript/tsup.config.ts @@ -0,0 +1,19 @@ +import { Options } from 'tsup'; + +const defaultOptions: Options = { + entry: ['src/**/*.ts'], + format: ['cjs', 'esm'], + splitting: false, + sourcemap: true, + // for the type maps to work, we use tsc's declaration-only command + dts: false, + clean: true, + target: 'node16', + bundle: false, + esbuildOptions: (options, context) => { + if (context.format === 'esm') { + options.packages = 'external'; + } + }, +}; +export default defaultOptions; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 19d9c342..9eb84fea 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -14,6 +14,9 @@ importers: '@livekit/changesets-changelog-github': specifier: ^0.0.4 version: 0.0.4 + esbuild: + specifier: ^0.24.0 + version: 0.24.0 packages/javascript: dependencies: @@ -27,6 +30,12 @@ importers: genversion: specifier: ^3.2.0 version: 3.2.0 + tsup: + specifier: ^8.3.5 + version: 8.3.5(typescript@5.7.2) + typescript: + specifier: ^5.7.2 + version: 5.7.2 packages: @@ -111,6 +120,172 @@ packages: '@changesets/write@0.3.2': resolution: {integrity: sha512-kDxDrPNpUgsjDbWBvUo27PzKX4gqeKOlhibaOXDJA6kuBisGqNHv/HwGJrAu8U/dSf8ZEFIeHIPtvSlZI1kULw==} + '@esbuild/aix-ppc64@0.24.0': + resolution: {integrity: sha512-WtKdFM7ls47zkKHFVzMz8opM7LkcsIp9amDUBIAWirg70RM71WRSjdILPsY5Uv1D42ZpUfaPILDlfactHgsRkw==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + + '@esbuild/android-arm64@0.24.0': + resolution: {integrity: sha512-Vsm497xFM7tTIPYK9bNTYJyF/lsP590Qc1WxJdlB6ljCbdZKU9SY8i7+Iin4kyhV/KV5J2rOKsBQbB77Ab7L/w==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm@0.24.0': + resolution: {integrity: sha512-arAtTPo76fJ/ICkXWetLCc9EwEHKaeya4vMrReVlEIUCAUncH7M4bhMQ+M9Vf+FFOZJdTNMXNBrWwW+OXWpSew==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + + '@esbuild/android-x64@0.24.0': + resolution: {integrity: sha512-t8GrvnFkiIY7pa7mMgJd7p8p8qqYIz1NYiAoKc75Zyv73L3DZW++oYMSHPRarcotTKuSs6m3hTOa5CKHaS02TQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + + '@esbuild/darwin-arm64@0.24.0': + resolution: {integrity: sha512-CKyDpRbK1hXwv79soeTJNHb5EiG6ct3efd/FTPdzOWdbZZfGhpbcqIpiD0+vwmpu0wTIL97ZRPZu8vUt46nBSw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-x64@0.24.0': + resolution: {integrity: sha512-rgtz6flkVkh58od4PwTRqxbKH9cOjaXCMZgWD905JOzjFKW+7EiUObfd/Kav+A6Gyud6WZk9w+xu6QLytdi2OA==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + + '@esbuild/freebsd-arm64@0.24.0': + resolution: {integrity: sha512-6Mtdq5nHggwfDNLAHkPlyLBpE5L6hwsuXZX8XNmHno9JuL2+bg2BX5tRkwjyfn6sKbxZTq68suOjgWqCicvPXA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.24.0': + resolution: {integrity: sha512-D3H+xh3/zphoX8ck4S2RxKR6gHlHDXXzOf6f/9dbFt/NRBDIE33+cVa49Kil4WUjxMGW0ZIYBYtaGCa2+OsQwQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + + '@esbuild/linux-arm64@0.24.0': + resolution: {integrity: sha512-TDijPXTOeE3eaMkRYpcy3LarIg13dS9wWHRdwYRnzlwlA370rNdZqbcp0WTyyV/k2zSxfko52+C7jU5F9Tfj1g==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm@0.24.0': + resolution: {integrity: sha512-gJKIi2IjRo5G6Glxb8d3DzYXlxdEj2NlkixPsqePSZMhLudqPhtZ4BUrpIuTjJYXxvF9njql+vRjB2oaC9XpBw==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-ia32@0.24.0': + resolution: {integrity: sha512-K40ip1LAcA0byL05TbCQ4yJ4swvnbzHscRmUilrmP9Am7//0UjPreh4lpYzvThT2Quw66MhjG//20mrufm40mA==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-loong64@0.24.0': + resolution: {integrity: sha512-0mswrYP/9ai+CU0BzBfPMZ8RVm3RGAN/lmOMgW4aFUSOQBjA31UP8Mr6DDhWSuMwj7jaWOT0p0WoZ6jeHhrD7g==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-mips64el@0.24.0': + resolution: {integrity: sha512-hIKvXm0/3w/5+RDtCJeXqMZGkI2s4oMUGj3/jM0QzhgIASWrGO5/RlzAzm5nNh/awHE0A19h/CvHQe6FaBNrRA==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-ppc64@0.24.0': + resolution: {integrity: sha512-HcZh5BNq0aC52UoocJxaKORfFODWXZxtBaaZNuN3PUX3MoDsChsZqopzi5UupRhPHSEHotoiptqikjN/B77mYQ==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-riscv64@0.24.0': + resolution: {integrity: sha512-bEh7dMn/h3QxeR2KTy1DUszQjUrIHPZKyO6aN1X4BCnhfYhuQqedHaa5MxSQA/06j3GpiIlFGSsy1c7Gf9padw==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-s390x@0.24.0': + resolution: {integrity: sha512-ZcQ6+qRkw1UcZGPyrCiHHkmBaj9SiCD8Oqd556HldP+QlpUIe2Wgn3ehQGVoPOvZvtHm8HPx+bH20c9pvbkX3g==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-x64@0.24.0': + resolution: {integrity: sha512-vbutsFqQ+foy3wSSbmjBXXIJ6PL3scghJoM8zCL142cGaZKAdCZHyf+Bpu/MmX9zT9Q0zFBVKb36Ma5Fzfa8xA==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + + '@esbuild/netbsd-x64@0.24.0': + resolution: {integrity: sha512-hjQ0R/ulkO8fCYFsG0FZoH+pWgTTDreqpqY7UnQntnaKv95uP5iW3+dChxnx7C3trQQU40S+OgWhUVwCjVFLvg==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + + '@esbuild/openbsd-arm64@0.24.0': + resolution: {integrity: sha512-MD9uzzkPQbYehwcN583yx3Tu5M8EIoTD+tUgKF982WYL9Pf5rKy9ltgD0eUgs8pvKnmizxjXZyLt0z6DC3rRXg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.24.0': + resolution: {integrity: sha512-4ir0aY1NGUhIC1hdoCzr1+5b43mw99uNwVzhIq1OY3QcEwPDO3B7WNXBzaKY5Nsf1+N11i1eOfFcq+D/gOS15Q==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + + '@esbuild/sunos-x64@0.24.0': + resolution: {integrity: sha512-jVzdzsbM5xrotH+W5f1s+JtUy1UWgjU0Cf4wMvffTB8m6wP5/kx0KiaLHlbJO+dMgtxKV8RQ/JvtlFcdZ1zCPA==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + + '@esbuild/win32-arm64@0.24.0': + resolution: {integrity: sha512-iKc8GAslzRpBytO2/aN3d2yb2z8XTVfNV0PjGlCxKo5SgWmNXx82I/Q3aG1tFfS+A2igVCY97TJ8tnYwpUWLCA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-ia32@0.24.0': + resolution: {integrity: sha512-vQW36KZolfIudCcTnaTpmLQ24Ha1RjygBo39/aLkM2kmjkWmZGEJ5Gn9l5/7tzXA42QGIoWbICfg6KLLkIw6yw==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-x64@0.24.0': + resolution: {integrity: sha512-7IAFPrjSQIJrGsK6flwg7NFmwBoSTyF3rl7If0hNUFQU4ilTsEPL6GuMuU9BfIWVVGuRnuIidkSMC+c0Otu8IA==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + + '@isaacs/cliui@8.0.2': + resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} + engines: {node: '>=12'} + + '@jridgewell/gen-mapping@0.3.5': + resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} + engines: {node: '>=6.0.0'} + + '@jridgewell/resolve-uri@3.1.2': + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + + '@jridgewell/set-array@1.2.1': + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} + + '@jridgewell/sourcemap-codec@1.5.0': + resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} + + '@jridgewell/trace-mapping@0.3.25': + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + '@livekit/changesets-changelog-github@0.0.4': resolution: {integrity: sha512-MXaiLYwgkYciZb8G2wkVtZ1pJJzZmVx5cM30Q+ClslrIYyAqQhRbPmZDM79/5CGxb1MTemR/tfOM25tgJgAK0g==} @@ -132,6 +307,103 @@ packages: resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} engines: {node: '>= 8'} + '@pkgjs/parseargs@0.11.0': + resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} + engines: {node: '>=14'} + + '@rollup/rollup-android-arm-eabi@4.27.4': + resolution: {integrity: sha512-2Y3JT6f5MrQkICUyRVCw4oa0sutfAsgaSsb0Lmmy1Wi2y7X5vT9Euqw4gOsCyy0YfKURBg35nhUKZS4mDcfULw==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.27.4': + resolution: {integrity: sha512-wzKRQXISyi9UdCVRqEd0H4cMpzvHYt1f/C3CoIjES6cG++RHKhrBj2+29nPF0IB5kpy9MS71vs07fvrNGAl/iA==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.27.4': + resolution: {integrity: sha512-PlNiRQapift4LNS8DPUHuDX/IdXiLjf8mc5vdEmUR0fF/pyy2qWwzdLjB+iZquGr8LuN4LnUoSEvKRwjSVYz3Q==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.27.4': + resolution: {integrity: sha512-o9bH2dbdgBDJaXWJCDTNDYa171ACUdzpxSZt+u/AAeQ20Nk5x+IhA+zsGmrQtpkLiumRJEYef68gcpn2ooXhSQ==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.27.4': + resolution: {integrity: sha512-NBI2/i2hT9Q+HySSHTBh52da7isru4aAAo6qC3I7QFVsuhxi2gM8t/EI9EVcILiHLj1vfi+VGGPaLOUENn7pmw==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.27.4': + resolution: {integrity: sha512-wYcC5ycW2zvqtDYrE7deary2P2UFmSh85PUpAx+dwTCO9uw3sgzD6Gv9n5X4vLaQKsrfTSZZ7Z7uynQozPVvWA==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.27.4': + resolution: {integrity: sha512-9OwUnK/xKw6DyRlgx8UizeqRFOfi9mf5TYCw1uolDaJSbUmBxP85DE6T4ouCMoN6pXw8ZoTeZCSEfSaYo+/s1w==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm-musleabihf@4.27.4': + resolution: {integrity: sha512-Vgdo4fpuphS9V24WOV+KwkCVJ72u7idTgQaBoLRD0UxBAWTF9GWurJO9YD9yh00BzbkhpeXtm6na+MvJU7Z73A==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm64-gnu@4.27.4': + resolution: {integrity: sha512-pleyNgyd1kkBkw2kOqlBx+0atfIIkkExOTiifoODo6qKDSpnc6WzUY5RhHdmTdIJXBdSnh6JknnYTtmQyobrVg==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-arm64-musl@4.27.4': + resolution: {integrity: sha512-caluiUXvUuVyCHr5DxL8ohaaFFzPGmgmMvwmqAITMpV/Q+tPoaHZ/PWa3t8B2WyoRcIIuu1hkaW5KkeTDNSnMA==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-powerpc64le-gnu@4.27.4': + resolution: {integrity: sha512-FScrpHrO60hARyHh7s1zHE97u0KlT/RECzCKAdmI+LEoC1eDh/RDji9JgFqyO+wPDb86Oa/sXkily1+oi4FzJQ==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-riscv64-gnu@4.27.4': + resolution: {integrity: sha512-qyyprhyGb7+RBfMPeww9FlHwKkCXdKHeGgSqmIXw9VSUtvyFZ6WZRtnxgbuz76FK7LyoN8t/eINRbPUcvXB5fw==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-s390x-gnu@4.27.4': + resolution: {integrity: sha512-PFz+y2kb6tbh7m3A7nA9++eInGcDVZUACulf/KzDtovvdTizHpZaJty7Gp0lFwSQcrnebHOqxF1MaKZd7psVRg==} + cpu: [s390x] + os: [linux] + + '@rollup/rollup-linux-x64-gnu@4.27.4': + resolution: {integrity: sha512-Ni8mMtfo+o/G7DVtweXXV/Ol2TFf63KYjTtoZ5f078AUgJTmaIJnj4JFU7TK/9SVWTaSJGxPi5zMDgK4w+Ez7Q==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-linux-x64-musl@4.27.4': + resolution: {integrity: sha512-5AeeAF1PB9TUzD+3cROzFTnAJAcVUGLuR8ng0E0WXGkYhp6RD6L+6szYVX+64Rs0r72019KHZS1ka1q+zU/wUw==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-win32-arm64-msvc@4.27.4': + resolution: {integrity: sha512-yOpVsA4K5qVwu2CaS3hHxluWIK5HQTjNV4tWjQXluMiiiu4pJj4BN98CvxohNCpcjMeTXk/ZMJBRbgRg8HBB6A==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.27.4': + resolution: {integrity: sha512-KtwEJOaHAVJlxV92rNYiG9JQwQAdhBlrjNRp7P9L8Cb4Rer3in+0A+IPhJC9y68WAi9H0sX4AiG2NTsVlmqJeQ==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.27.4': + resolution: {integrity: sha512-3j4jx1TppORdTAoBJRd+/wJRGCPC0ETWkXOecJ6PPZLj6SptXkrXcNqdj0oclbKML6FkQltdz7bBA3rUSirZug==} + cpu: [x64] + os: [win32] + + '@types/estree@1.0.6': + resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==} + '@types/node@12.20.55': resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} @@ -148,10 +420,21 @@ packages: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} + ansi-regex@6.1.0: + resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==} + engines: {node: '>=12'} + ansi-styles@4.3.0: resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} engines: {node: '>=8'} + ansi-styles@6.2.1: + resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==} + engines: {node: '>=12'} + + any-promise@1.3.0: + resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} + argparse@1.0.10: resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} @@ -179,6 +462,16 @@ packages: resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} engines: {node: '>=8'} + bundle-require@5.0.0: + resolution: {integrity: sha512-GuziW3fSSmopcx4KRymQEJVbZUfqlCqcq7dvs6TYwKRZiegK/2buMxQTPs6MGlNv50wms1699qYO54R8XfRX4w==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + peerDependencies: + esbuild: '>=0.18' + + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} + chalk@4.1.2: resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} engines: {node: '>=10'} @@ -186,6 +479,10 @@ packages: chardet@0.7.0: resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} + chokidar@4.0.1: + resolution: {integrity: sha512-n8enUVCED/KVRQlab1hr3MVpcVMvxtZjmEa956u+4YijlmQED223XMSYj2tLuKvr4jcCTzNNMpQDUer72MMmzA==} + engines: {node: '>= 14.16.0'} + ci-info@3.9.0: resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} engines: {node: '>=8'} @@ -197,6 +494,10 @@ packages: color-name@1.1.4: resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + commander@4.1.1: + resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==} + engines: {node: '>= 6'} + commander@7.2.0: resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==} engines: {node: '>= 10'} @@ -204,9 +505,17 @@ packages: concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + consola@3.2.3: + resolution: {integrity: sha512-I5qxpzLv+sJhTVEoLYNcTW+bThDCPsit0vLNKShZx6rLtpilNpmmeTPaeqJb9ZE9dV3DGaeby6Vuhrw38WjeyQ==} + engines: {node: ^14.18.0 || >=16.10.0} + cross-spawn@5.1.0: resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==} + cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} + dataloader@1.4.0: resolution: {integrity: sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==} @@ -219,6 +528,15 @@ packages: supports-color: optional: true + debug@4.3.7: + resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + detect-indent@6.1.0: resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} engines: {node: '>=8'} @@ -231,15 +549,29 @@ packages: resolution: {integrity: sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==} engines: {node: '>=10'} + eastasianwidth@0.2.0: + resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + ejs@3.1.10: resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==} engines: {node: '>=0.10.0'} hasBin: true + emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + + emoji-regex@9.2.2: + resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} + enquirer@2.4.1: resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} engines: {node: '>=8.6'} + esbuild@0.24.0: + resolution: {integrity: sha512-FuLPevChGDshgSicjisSooU0cemp/sGXR841D5LHMB7mTVOmsEHcAxaH3irL53+8YDIeVNQEySh4DaYU/iuPqQ==} + engines: {node: '>=18'} + hasBin: true + esprima@4.0.1: resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} engines: {node: '>=4'} @@ -259,6 +591,14 @@ packages: fastq@1.17.1: resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} + fdir@6.4.2: + resolution: {integrity: sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + filelist@1.0.4: resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} @@ -273,6 +613,10 @@ packages: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} + foreground-child@3.3.0: + resolution: {integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==} + engines: {node: '>=14'} + fs-extra@7.0.1: resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} engines: {node: '>=6 <7 || >=8'} @@ -281,6 +625,11 @@ packages: resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==} engines: {node: '>=6 <7 || >=8'} + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + genversion@3.2.0: resolution: {integrity: sha512-OIYSX6XYA8PHecLDCTri30hadSZfAjZ8Iq1+BBDXqLWP4dRLuJNLoNjsSWtTpw97IccK2LDWzkEstxAB8GdN7g==} engines: {node: '>=10.0.0'} @@ -290,6 +639,10 @@ packages: resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} engines: {node: '>= 6'} + glob@10.4.5: + resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==} + hasBin: true + globby@11.1.0: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} @@ -316,6 +669,10 @@ packages: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} + is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} + is-glob@4.0.3: resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} engines: {node: '>=0.10.0'} @@ -335,11 +692,18 @@ packages: isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + jackspeak@3.4.3: + resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + jake@10.9.2: resolution: {integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==} engines: {node: '>=10'} hasBin: true + joycon@3.1.1: + resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==} + engines: {node: '>=10'} + js-yaml@3.14.1: resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} hasBin: true @@ -347,13 +711,30 @@ packages: jsonfile@4.0.0: resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} + lilconfig@3.1.2: + resolution: {integrity: sha512-eop+wDAvpItUys0FWkHIKeC9ybYrTGbU41U5K7+bttZZeohvnY7M9dZ5kB21GNWiFT2q1OoPTvncPCgSOVO5ow==} + engines: {node: '>=14'} + + lines-and-columns@1.2.4: + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + + load-tsconfig@0.2.5: + resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + locate-path@5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} + lodash.sortby@4.7.0: + resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} + lodash.startcase@4.4.0: resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==} + lru-cache@10.4.3: + resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} + lru-cache@4.1.5: resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} @@ -372,6 +753,14 @@ packages: resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} engines: {node: '>=10'} + minimatch@9.0.5: + resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} + engines: {node: '>=16 || 14 >=14.17'} + + minipass@7.1.2: + resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} + engines: {node: '>=16 || 14 >=14.17'} + mri@1.2.0: resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==} engines: {node: '>=4'} @@ -379,6 +768,12 @@ packages: ms@2.1.2: resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + mz@2.7.0: + resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} + node-fetch@2.7.0: resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} engines: {node: 4.x || >=6.0.0} @@ -388,6 +783,10 @@ packages: encoding: optional: true + object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} + os-tmpdir@1.0.2: resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} engines: {node: '>=0.10.0'} @@ -415,6 +814,9 @@ packages: resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} engines: {node: '>=6'} + package-json-from-dist@1.0.1: + resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} + package-manager-detector@0.2.2: resolution: {integrity: sha512-VgXbyrSNsml4eHWIvxxG/nTL4wgybMTXCV2Un/+yEc3aDKKU6nQBZjbeP3Pl3qm9Qg92X/1ng4ffvCeD/zwHgg==} @@ -425,10 +827,18 @@ packages: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} + path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + path-platform@0.11.15: resolution: {integrity: sha512-Y30dB6rab1A/nfEKsZxmr01nUotHX0c/ZiIAsCTatEe1CmS5Pm5He7fZ195bPT7RdquoaL8lLxFCMQi/bS7IJg==} engines: {node: '>= 0.8.0'} + path-scurry@1.11.1: + resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} + engines: {node: '>=16 || 14 >=14.18'} + path-type@4.0.0: resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} engines: {node: '>=8'} @@ -440,10 +850,36 @@ packages: resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} engines: {node: '>=8.6'} + picomatch@4.0.2: + resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==} + engines: {node: '>=12'} + pify@4.0.1: resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==} engines: {node: '>=6'} + pirates@4.0.6: + resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} + engines: {node: '>= 6'} + + postcss-load-config@6.0.1: + resolution: {integrity: sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==} + engines: {node: '>= 18'} + peerDependencies: + jiti: '>=1.21.0' + postcss: '>=8.0.9' + tsx: ^4.8.1 + yaml: ^2.4.2 + peerDependenciesMeta: + jiti: + optional: true + postcss: + optional: true + tsx: + optional: true + yaml: + optional: true + prettier@2.8.8: resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} engines: {node: '>=10.13.0'} @@ -452,6 +888,10 @@ packages: pseudomap@1.0.2: resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==} + punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} @@ -459,6 +899,10 @@ packages: resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==} engines: {node: '>=6'} + readdirp@4.0.2: + resolution: {integrity: sha512-yDMz9g+VaZkqBYS/ozoBJwaBhTbZo3UNYQHNRw1D3UFQB8oHB4uS/tAODO+ZLjGWmUbKnIlOWO+aaIiAxrUWHA==} + engines: {node: '>= 14.16.0'} + regenerator-runtime@0.14.1: resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} @@ -470,6 +914,11 @@ packages: resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + rollup@4.27.4: + resolution: {integrity: sha512-RLKxqHEMjh/RGLsDxAEsaLO3mWgyoU6x9w6n1ikAzet4B3gI2/3yP6PWY2p9QzRTh6MfEIXB3MwsOY0Iv3vNrw==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + run-parallel@1.2.0: resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} @@ -485,31 +934,64 @@ packages: resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} engines: {node: '>=0.10.0'} + shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + shebang-regex@1.0.0: resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==} engines: {node: '>=0.10.0'} + shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + signal-exit@3.0.7: resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} + signal-exit@4.1.0: + resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} + engines: {node: '>=14'} + slash@3.0.0: resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} engines: {node: '>=8'} + source-map@0.8.0-beta.0: + resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} + engines: {node: '>= 8'} + spawndamnit@2.0.0: resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} sprintf-js@1.0.3: resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + string-width@4.2.3: + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} + + string-width@5.1.2: + resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} + engines: {node: '>=12'} + strip-ansi@6.0.1: resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} engines: {node: '>=8'} + strip-ansi@7.1.0: + resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} + engines: {node: '>=12'} + strip-bom@3.0.0: resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} engines: {node: '>=4'} + sucrase@3.35.0: + resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} + engines: {node: '>=16 || 14 >=14.17'} + hasBin: true + supports-color@7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} @@ -518,6 +1000,20 @@ packages: resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} engines: {node: '>=8'} + thenify-all@1.6.0: + resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} + engines: {node: '>=0.8'} + + thenify@3.3.1: + resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} + + tinyexec@0.3.1: + resolution: {integrity: sha512-WiCJLEECkO18gwqIp6+hJg0//p23HXp4S+gGtAKu3mI2F2/sXC4FvHvXvB0zJVVaTPhx1/tOwdbRsa1sOBIKqQ==} + + tinyglobby@0.2.10: + resolution: {integrity: sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==} + engines: {node: '>=12.0.0'} + tmp@0.0.33: resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} engines: {node: '>=0.6.0'} @@ -529,11 +1025,45 @@ packages: tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + tr46@1.0.1: + resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + + tree-kill@1.2.2: + resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} + hasBin: true + + ts-interface-checker@0.1.13: + resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} + + tsup@8.3.5: + resolution: {integrity: sha512-Tunf6r6m6tnZsG9GYWndg0z8dEV7fD733VBFzFJ5Vcm1FtlXB8xBD/rtrBi2a3YKEV7hHtxiZtW5EAVADoe1pA==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + '@microsoft/api-extractor': ^7.36.0 + '@swc/core': ^1 + postcss: ^8.4.12 + typescript: '>=4.5.0' + peerDependenciesMeta: + '@microsoft/api-extractor': + optional: true + '@swc/core': + optional: true + postcss: + optional: true + typescript: + optional: true + typescript@4.5.2: resolution: {integrity: sha512-5BlMof9H1yGt0P8/WF+wPNw6GfctgGjXp5hkblpyT+8rkASSmkUKMXrxR0Xg8ThVCi/JnHQiKXeBaEwCeQwMFw==} engines: {node: '>=4.2.0'} hasBin: true + typescript@5.7.2: + resolution: {integrity: sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==} + engines: {node: '>=14.17'} + hasBin: true + universalify@0.1.2: resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} engines: {node: '>= 4.0.0'} @@ -541,13 +1071,32 @@ packages: webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + webidl-conversions@4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + whatwg-url@5.0.0: resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + whatwg-url@7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} + which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true + which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + + wrap-ansi@7.0.0: + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + engines: {node: '>=10'} + + wrap-ansi@8.1.0: + resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} + engines: {node: '>=12'} + yallist@2.1.2: resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==} @@ -726,6 +1275,104 @@ snapshots: human-id: 1.0.2 prettier: 2.8.8 + '@esbuild/aix-ppc64@0.24.0': + optional: true + + '@esbuild/android-arm64@0.24.0': + optional: true + + '@esbuild/android-arm@0.24.0': + optional: true + + '@esbuild/android-x64@0.24.0': + optional: true + + '@esbuild/darwin-arm64@0.24.0': + optional: true + + '@esbuild/darwin-x64@0.24.0': + optional: true + + '@esbuild/freebsd-arm64@0.24.0': + optional: true + + '@esbuild/freebsd-x64@0.24.0': + optional: true + + '@esbuild/linux-arm64@0.24.0': + optional: true + + '@esbuild/linux-arm@0.24.0': + optional: true + + '@esbuild/linux-ia32@0.24.0': + optional: true + + '@esbuild/linux-loong64@0.24.0': + optional: true + + '@esbuild/linux-mips64el@0.24.0': + optional: true + + '@esbuild/linux-ppc64@0.24.0': + optional: true + + '@esbuild/linux-riscv64@0.24.0': + optional: true + + '@esbuild/linux-s390x@0.24.0': + optional: true + + '@esbuild/linux-x64@0.24.0': + optional: true + + '@esbuild/netbsd-x64@0.24.0': + optional: true + + '@esbuild/openbsd-arm64@0.24.0': + optional: true + + '@esbuild/openbsd-x64@0.24.0': + optional: true + + '@esbuild/sunos-x64@0.24.0': + optional: true + + '@esbuild/win32-arm64@0.24.0': + optional: true + + '@esbuild/win32-ia32@0.24.0': + optional: true + + '@esbuild/win32-x64@0.24.0': + optional: true + + '@isaacs/cliui@8.0.2': + dependencies: + string-width: 5.1.2 + string-width-cjs: string-width@4.2.3 + strip-ansi: 7.1.0 + strip-ansi-cjs: strip-ansi@6.0.1 + wrap-ansi: 8.1.0 + wrap-ansi-cjs: wrap-ansi@7.0.0 + + '@jridgewell/gen-mapping@0.3.5': + dependencies: + '@jridgewell/set-array': 1.2.1 + '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping': 0.3.25 + + '@jridgewell/resolve-uri@3.1.2': {} + + '@jridgewell/set-array@1.2.1': {} + + '@jridgewell/sourcemap-codec@1.5.0': {} + + '@jridgewell/trace-mapping@0.3.25': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.0 + '@livekit/changesets-changelog-github@0.0.4': dependencies: '@changesets/get-github-info': 0.5.2 @@ -762,6 +1409,65 @@ snapshots: '@nodelib/fs.scandir': 2.1.5 fastq: 1.17.1 + '@pkgjs/parseargs@0.11.0': + optional: true + + '@rollup/rollup-android-arm-eabi@4.27.4': + optional: true + + '@rollup/rollup-android-arm64@4.27.4': + optional: true + + '@rollup/rollup-darwin-arm64@4.27.4': + optional: true + + '@rollup/rollup-darwin-x64@4.27.4': + optional: true + + '@rollup/rollup-freebsd-arm64@4.27.4': + optional: true + + '@rollup/rollup-freebsd-x64@4.27.4': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.27.4': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.27.4': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.27.4': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.27.4': + optional: true + + '@rollup/rollup-linux-powerpc64le-gnu@4.27.4': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.27.4': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.27.4': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.27.4': + optional: true + + '@rollup/rollup-linux-x64-musl@4.27.4': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.27.4': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.27.4': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.27.4': + optional: true + + '@types/estree@1.0.6': {} + '@types/node@12.20.55': {} '@typescript/vfs@1.5.3(typescript@4.5.2)': @@ -775,10 +1481,16 @@ snapshots: ansi-regex@5.0.1: {} + ansi-regex@6.1.0: {} + ansi-styles@4.3.0: dependencies: color-convert: 2.0.1 + ansi-styles@6.2.1: {} + + any-promise@1.3.0: {} + argparse@1.0.10: dependencies: sprintf-js: 1.0.3 @@ -806,6 +1518,13 @@ snapshots: dependencies: fill-range: 7.1.1 + bundle-require@5.0.0(esbuild@0.24.0): + dependencies: + esbuild: 0.24.0 + load-tsconfig: 0.2.5 + + cac@6.7.14: {} + chalk@4.1.2: dependencies: ansi-styles: 4.3.0 @@ -813,6 +1532,10 @@ snapshots: chardet@0.7.0: {} + chokidar@4.0.1: + dependencies: + readdirp: 4.0.2 + ci-info@3.9.0: {} color-convert@2.0.1: @@ -821,22 +1544,36 @@ snapshots: color-name@1.1.4: {} + commander@4.1.1: {} + commander@7.2.0: {} concat-map@0.0.1: {} + consola@3.2.3: {} + cross-spawn@5.1.0: dependencies: lru-cache: 4.1.5 shebang-command: 1.2.0 which: 1.3.1 + cross-spawn@7.0.6: + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + dataloader@1.4.0: {} debug@4.3.5: dependencies: ms: 2.1.2 + debug@4.3.7: + dependencies: + ms: 2.1.3 + detect-indent@6.1.0: {} dir-glob@3.0.1: @@ -845,15 +1582,48 @@ snapshots: dotenv@8.6.0: {} + eastasianwidth@0.2.0: {} + ejs@3.1.10: dependencies: jake: 10.9.2 + emoji-regex@8.0.0: {} + + emoji-regex@9.2.2: {} + enquirer@2.4.1: dependencies: ansi-colors: 4.1.3 strip-ansi: 6.0.1 + esbuild@0.24.0: + optionalDependencies: + '@esbuild/aix-ppc64': 0.24.0 + '@esbuild/android-arm': 0.24.0 + '@esbuild/android-arm64': 0.24.0 + '@esbuild/android-x64': 0.24.0 + '@esbuild/darwin-arm64': 0.24.0 + '@esbuild/darwin-x64': 0.24.0 + '@esbuild/freebsd-arm64': 0.24.0 + '@esbuild/freebsd-x64': 0.24.0 + '@esbuild/linux-arm': 0.24.0 + '@esbuild/linux-arm64': 0.24.0 + '@esbuild/linux-ia32': 0.24.0 + '@esbuild/linux-loong64': 0.24.0 + '@esbuild/linux-mips64el': 0.24.0 + '@esbuild/linux-ppc64': 0.24.0 + '@esbuild/linux-riscv64': 0.24.0 + '@esbuild/linux-s390x': 0.24.0 + '@esbuild/linux-x64': 0.24.0 + '@esbuild/netbsd-x64': 0.24.0 + '@esbuild/openbsd-arm64': 0.24.0 + '@esbuild/openbsd-x64': 0.24.0 + '@esbuild/sunos-x64': 0.24.0 + '@esbuild/win32-arm64': 0.24.0 + '@esbuild/win32-ia32': 0.24.0 + '@esbuild/win32-x64': 0.24.0 + esprima@4.0.1: {} extendable-error@0.1.7: {} @@ -876,6 +1646,10 @@ snapshots: dependencies: reusify: 1.0.4 + fdir@6.4.2(picomatch@4.0.2): + optionalDependencies: + picomatch: 4.0.2 + filelist@1.0.4: dependencies: minimatch: 5.1.6 @@ -893,6 +1667,11 @@ snapshots: locate-path: 5.0.0 path-exists: 4.0.0 + foreground-child@3.3.0: + dependencies: + cross-spawn: 7.0.6 + signal-exit: 4.1.0 + fs-extra@7.0.1: dependencies: graceful-fs: 4.2.11 @@ -905,6 +1684,9 @@ snapshots: jsonfile: 4.0.0 universalify: 0.1.2 + fsevents@2.3.3: + optional: true + genversion@3.2.0: dependencies: commander: 7.2.0 @@ -915,6 +1697,15 @@ snapshots: dependencies: is-glob: 4.0.3 + glob@10.4.5: + dependencies: + foreground-child: 3.3.0 + jackspeak: 3.4.3 + minimatch: 9.0.5 + minipass: 7.1.2 + package-json-from-dist: 1.0.1 + path-scurry: 1.11.1 + globby@11.1.0: dependencies: array-union: 2.1.0 @@ -938,6 +1729,8 @@ snapshots: is-extglob@2.1.1: {} + is-fullwidth-code-point@3.0.0: {} + is-glob@4.0.3: dependencies: is-extglob: 2.1.1 @@ -952,6 +1745,12 @@ snapshots: isexe@2.0.0: {} + jackspeak@3.4.3: + dependencies: + '@isaacs/cliui': 8.0.2 + optionalDependencies: + '@pkgjs/parseargs': 0.11.0 + jake@10.9.2: dependencies: async: 3.2.6 @@ -959,6 +1758,8 @@ snapshots: filelist: 1.0.4 minimatch: 3.1.2 + joycon@3.1.1: {} + js-yaml@3.14.1: dependencies: argparse: 1.0.10 @@ -968,12 +1769,22 @@ snapshots: optionalDependencies: graceful-fs: 4.2.11 + lilconfig@3.1.2: {} + + lines-and-columns@1.2.4: {} + + load-tsconfig@0.2.5: {} + locate-path@5.0.0: dependencies: p-locate: 4.1.0 + lodash.sortby@4.7.0: {} + lodash.startcase@4.4.0: {} + lru-cache@10.4.3: {} + lru-cache@4.1.5: dependencies: pseudomap: 1.0.2 @@ -994,14 +1805,30 @@ snapshots: dependencies: brace-expansion: 2.0.1 + minimatch@9.0.5: + dependencies: + brace-expansion: 2.0.1 + + minipass@7.1.2: {} + mri@1.2.0: {} ms@2.1.2: {} + ms@2.1.3: {} + + mz@2.7.0: + dependencies: + any-promise: 1.3.0 + object-assign: 4.1.1 + thenify-all: 1.6.0 + node-fetch@2.7.0: dependencies: whatwg-url: 5.0.0 + object-assign@4.1.1: {} + os-tmpdir@1.0.2: {} outdent@0.5.0: {} @@ -1022,6 +1849,8 @@ snapshots: p-try@2.2.0: {} + package-json-from-dist@1.0.1: {} + package-manager-detector@0.2.2: {} parents@1.0.1: @@ -1030,20 +1859,37 @@ snapshots: path-exists@4.0.0: {} + path-key@3.1.1: {} + path-platform@0.11.15: {} + path-scurry@1.11.1: + dependencies: + lru-cache: 10.4.3 + minipass: 7.1.2 + path-type@4.0.0: {} picocolors@1.1.1: {} picomatch@2.3.1: {} + picomatch@4.0.2: {} + pify@4.0.1: {} + pirates@4.0.6: {} + + postcss-load-config@6.0.1: + dependencies: + lilconfig: 3.1.2 + prettier@2.8.8: {} pseudomap@1.0.2: {} + punycode@2.3.1: {} + queue-microtask@1.2.3: {} read-yaml-file@1.1.0: @@ -1053,12 +1899,38 @@ snapshots: pify: 4.0.1 strip-bom: 3.0.0 + readdirp@4.0.2: {} + regenerator-runtime@0.14.1: {} resolve-from@5.0.0: {} reusify@1.0.4: {} + rollup@4.27.4: + dependencies: + '@types/estree': 1.0.6 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.27.4 + '@rollup/rollup-android-arm64': 4.27.4 + '@rollup/rollup-darwin-arm64': 4.27.4 + '@rollup/rollup-darwin-x64': 4.27.4 + '@rollup/rollup-freebsd-arm64': 4.27.4 + '@rollup/rollup-freebsd-x64': 4.27.4 + '@rollup/rollup-linux-arm-gnueabihf': 4.27.4 + '@rollup/rollup-linux-arm-musleabihf': 4.27.4 + '@rollup/rollup-linux-arm64-gnu': 4.27.4 + '@rollup/rollup-linux-arm64-musl': 4.27.4 + '@rollup/rollup-linux-powerpc64le-gnu': 4.27.4 + '@rollup/rollup-linux-riscv64-gnu': 4.27.4 + '@rollup/rollup-linux-s390x-gnu': 4.27.4 + '@rollup/rollup-linux-x64-gnu': 4.27.4 + '@rollup/rollup-linux-x64-musl': 4.27.4 + '@rollup/rollup-win32-arm64-msvc': 4.27.4 + '@rollup/rollup-win32-ia32-msvc': 4.27.4 + '@rollup/rollup-win32-x64-msvc': 4.27.4 + fsevents: 2.3.3 + run-parallel@1.2.0: dependencies: queue-microtask: 1.2.3 @@ -1071,12 +1943,24 @@ snapshots: dependencies: shebang-regex: 1.0.0 + shebang-command@2.0.0: + dependencies: + shebang-regex: 3.0.0 + shebang-regex@1.0.0: {} + shebang-regex@3.0.0: {} + signal-exit@3.0.7: {} + signal-exit@4.1.0: {} + slash@3.0.0: {} + source-map@0.8.0-beta.0: + dependencies: + whatwg-url: 7.1.0 + spawndamnit@2.0.0: dependencies: cross-spawn: 5.1.0 @@ -1084,18 +1968,59 @@ snapshots: sprintf-js@1.0.3: {} + string-width@4.2.3: + dependencies: + emoji-regex: 8.0.0 + is-fullwidth-code-point: 3.0.0 + strip-ansi: 6.0.1 + + string-width@5.1.2: + dependencies: + eastasianwidth: 0.2.0 + emoji-regex: 9.2.2 + strip-ansi: 7.1.0 + strip-ansi@6.0.1: dependencies: ansi-regex: 5.0.1 + strip-ansi@7.1.0: + dependencies: + ansi-regex: 6.1.0 + strip-bom@3.0.0: {} + sucrase@3.35.0: + dependencies: + '@jridgewell/gen-mapping': 0.3.5 + commander: 4.1.1 + glob: 10.4.5 + lines-and-columns: 1.2.4 + mz: 2.7.0 + pirates: 4.0.6 + ts-interface-checker: 0.1.13 + supports-color@7.2.0: dependencies: has-flag: 4.0.0 term-size@2.2.1: {} + thenify-all@1.6.0: + dependencies: + thenify: 3.3.1 + + thenify@3.3.1: + dependencies: + any-promise: 1.3.0 + + tinyexec@0.3.1: {} + + tinyglobby@0.2.10: + dependencies: + fdir: 6.4.2(picomatch@4.0.2) + picomatch: 4.0.2 + tmp@0.0.33: dependencies: os-tmpdir: 1.0.2 @@ -1106,19 +2031,79 @@ snapshots: tr46@0.0.3: {} + tr46@1.0.1: + dependencies: + punycode: 2.3.1 + + tree-kill@1.2.2: {} + + ts-interface-checker@0.1.13: {} + + tsup@8.3.5(typescript@5.7.2): + dependencies: + bundle-require: 5.0.0(esbuild@0.24.0) + cac: 6.7.14 + chokidar: 4.0.1 + consola: 3.2.3 + debug: 4.3.7 + esbuild: 0.24.0 + joycon: 3.1.1 + picocolors: 1.1.1 + postcss-load-config: 6.0.1 + resolve-from: 5.0.0 + rollup: 4.27.4 + source-map: 0.8.0-beta.0 + sucrase: 3.35.0 + tinyexec: 0.3.1 + tinyglobby: 0.2.10 + tree-kill: 1.2.2 + optionalDependencies: + typescript: 5.7.2 + transitivePeerDependencies: + - jiti + - supports-color + - tsx + - yaml + typescript@4.5.2: {} + typescript@5.7.2: {} + universalify@0.1.2: {} webidl-conversions@3.0.1: {} + webidl-conversions@4.0.2: {} + whatwg-url@5.0.0: dependencies: tr46: 0.0.3 webidl-conversions: 3.0.1 + whatwg-url@7.1.0: + dependencies: + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 + which@1.3.1: dependencies: isexe: 2.0.0 + which@2.0.2: + dependencies: + isexe: 2.0.0 + + wrap-ansi@7.0.0: + dependencies: + ansi-styles: 4.3.0 + string-width: 4.2.3 + strip-ansi: 6.0.1 + + wrap-ansi@8.1.0: + dependencies: + ansi-styles: 6.2.1 + string-width: 5.1.2 + strip-ansi: 7.1.0 + yallist@2.1.2: {}