Add js protocol package (#601)

* Add js protocol package

* add agent and webhook

* fix version

* remove unneeded tsconfig

* add index type file

* Add js release action

* test workflow

* install protoc

* install nodejs first

* remove dev branch

* move into packages folder

* add other files

* add egress, ingress, sip

* fix commit path

* Add types entry point

* add gitattributes

* no dry run

.gitattributes

@@ -0,0 +1 @@
+packages/js/src/gen/* linguist-generated=true

.github/workflows/release-js.yaml

@@ -0,0 +1,60 @@
+# 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.
+
+name: Generate and release JS protocol package
+
+on:
+  workflow_dispatch:
+  push:
+    branches: ["main"]
+
+defaults:
+  run:
+    working-directory: ./packages/js
+
+jobs:
+  generate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      - name: Use Node.js 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "pnpm"
+          cache-dependency-path: "packages/js/pnpm-lock.yaml"
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+      - name: Install dependencies
+        run: pnpm install
+      - name: Version package
+        if: startsWith(github.event.ref, 'refs/tags/v')
+        run: npm version from-git
+      - name: Generate files
+        run: |
+          pnpm generate:version
+          pnpm generate:proto
+      - name: Add changes
+        uses: EndBug/add-and-commit@v9
+        with:
+          add: '["packages/js"]'
+          default_author: github_actions
+          message: auto-generated JS files
+      - name: Publish
+        if: startsWith(github.event.ref, 'refs/tags/v')
+        run: pnpm ci:publish

packages/js/.gitignore

@@ -0,0 +1 @@
+node_modules/

packages/js/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@livekit/protocol",
+  "version": "13.0.0",
+  "description": "",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "generate:version": "genversion --esm --semi src/gen/version.js",
+    "generate:proto": "protoc --es_out src/gen --es_opt target=js+dts -I=../../ ../../livekit_rtc.proto ../../livekit_models.proto ../../livekit_agent.proto ../../livekit_webhook.proto ../../livekit_egress.proto ../../livekit_ingress.proto ../../livekit_sip.proto",
+    "ci:publish": "pnpm publish"
+  },
+  "keywords": [],
+  "author": "LiveKit",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@bufbuild/buf": "^1.29.0",
+    "@bufbuild/protoc-gen-es": "^1.7.2",
+    "genversion": "^3.2.0"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^1.7.2"
+  }
+}

packages/js/pnpm-lock.yaml

@@ -0,0 +1,283 @@
+lockfileVersion: '6.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+dependencies:
+  '@bufbuild/protobuf':
+    specifier: ^1.7.2
+    version: 1.7.2
+
+devDependencies:
+  '@bufbuild/buf':
+    specifier: ^1.29.0
+    version: 1.29.0
+  '@bufbuild/protoc-gen-es':
+    specifier: ^1.7.2
+    version: 1.7.2(@bufbuild/protobuf@1.7.2)
+  genversion:
+    specifier: ^3.2.0
+    version: 3.2.0
+
+packages:
+
+  /@bufbuild/buf-darwin-arm64@1.29.0:
+    resolution: {integrity: sha512-5hKxsARoY2WpWq1n5ONFqqGuauHb4yILKXCy37KRYCKiRLWmIP5yI3gWvWHKoH7sUJWTQmBqdJoCvYQr6ahQnw==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf-darwin-x64@1.29.0:
+    resolution: {integrity: sha512-wOAPxbPLBns4AHiComWtdO1sx1J1p6mDYTbqmloHuI+B5U2rDbMsoHoe4nBcoMF8+RHxoqjypha29wVo6yzbZg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf-linux-aarch64@1.29.0:
+    resolution: {integrity: sha512-jLk2J/wyyM7KNJ/DkLfhy3eS2/Bdb70e/56adMkapSoLJmghnpgxW+oFznMxxQUX5I9BU5hTn1UhDFxgLwhP7g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf-linux-x64@1.29.0:
+    resolution: {integrity: sha512-heLOywj3Oaoh69RnTx7tHsuz6rEnvz77bghLEOghsrjBR6Jcpcwc137EZR4kRTIWJNrE8Kmo3RVeXlv144qQIQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf-win32-arm64@1.29.0:
+    resolution: {integrity: sha512-Eglyvr3PLqVucuHBcQ61conyBgH9BRaoLpKWcce1gYBVlxMQM1NxjVjGOWihxQ1dXXw5qZXmYfVODf3gSwPMuQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf-win32-x64@1.29.0:
+    resolution: {integrity: sha512-wRk6co+nqHqEq4iLolXgej0jUVlWlTtGHjKaq54lTbKZrwxrBgql6qS06abgNPRASX0++XT9m3QRZ97qEIC/HQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@bufbuild/buf@1.29.0:
+    resolution: {integrity: sha512-euksXeFtvlvAV5j94LqXb69qQcJvFfo8vN1d3cx+IzhOKoipykuQQTq7mOWVo2R0kdk6yIMBLBofOYOsh0Df8g==}
+    engines: {node: '>=12'}
+    hasBin: true
+    requiresBuild: true
+    optionalDependencies:
+      '@bufbuild/buf-darwin-arm64': 1.29.0
+      '@bufbuild/buf-darwin-x64': 1.29.0
+      '@bufbuild/buf-linux-aarch64': 1.29.0
+      '@bufbuild/buf-linux-x64': 1.29.0
+      '@bufbuild/buf-win32-arm64': 1.29.0
+      '@bufbuild/buf-win32-x64': 1.29.0
+    dev: true
+
+  /@bufbuild/protobuf@1.7.2:
+    resolution: {integrity: sha512-i5GE2Dk5ekdlK1TR7SugY4LWRrKSfb5T1Qn4unpIMbfxoeGKERKQ59HG3iYewacGD10SR7UzevfPnh6my4tNmQ==}
+
+  /@bufbuild/protoc-gen-es@1.7.2(@bufbuild/protobuf@1.7.2):
+    resolution: {integrity: sha512-yiRk/T+YGmpSVvIkybCjPt+QyM/pLWMO+MAiz6auvCsiAgfXfc5nFFosD4yBYXID55M6eIkgBcity1AoJ6I30A==}
+    engines: {node: '>=14'}
+    hasBin: true
+    peerDependencies:
+      '@bufbuild/protobuf': 1.7.2
+    peerDependenciesMeta:
+      '@bufbuild/protobuf':
+        optional: true
+    dependencies:
+      '@bufbuild/protobuf': 1.7.2
+      '@bufbuild/protoplugin': 1.7.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@bufbuild/protoplugin@1.7.2:
+    resolution: {integrity: sha512-N3QtO8XWD4F4alMtASWtxBw6BWXp4aLz7rPBXH4KTULdjpUHnq46g15TsrG0/8szZw6pIklTO3lFe14dl6ZYdA==}
+    dependencies:
+      '@bufbuild/protobuf': 1.7.2
+      '@typescript/vfs': 1.5.0
+      typescript: 4.5.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript/vfs@1.5.0:
+    resolution: {integrity: sha512-AJS307bPgbsZZ9ggCT3wwpg3VbTKMFNHfaY/uF0ahSkYYrPF2dSSKDNIDIQAHm9qJqbLvCsSJH7yN4Vs/CsMMg==}
+    dependencies:
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+    dependencies:
+      color-convert: 2.0.1
+    dev: true
+
+  /async@3.2.5:
+    resolution: {integrity: sha512-baNZyqaaLhyLVKm/DlvdW051MSgO6b8eVfIezl9E5PqWxFgzLm/wQntEW4zOytVburDEr0JlALEpdOFwvErLsg==}
+    dev: true
+
+  /balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+    dev: true
+
+  /brace-expansion@1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+    dev: true
+
+  /brace-expansion@2.0.1:
+    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+    dependencies:
+      balanced-match: 1.0.2
+    dev: true
+
+  /chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+    dev: true
+
+  /color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+    dependencies:
+      color-name: 1.1.4
+    dev: true
+
+  /color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+    dev: true
+
+  /commander@7.2.0:
+    resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
+    engines: {node: '>= 10'}
+    dev: true
+
+  /concat-map@0.0.1:
+    resolution: {integrity: sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=}
+    dev: true
+
+  /debug@4.3.4:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.2
+    dev: true
+
+  /ejs@3.1.9:
+    resolution: {integrity: sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+    dependencies:
+      jake: 10.8.7
+    dev: true
+
+  /filelist@1.0.4:
+    resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==}
+    dependencies:
+      minimatch: 5.1.6
+    dev: true
+
+  /find-package@1.0.0:
+    resolution: {integrity: sha512-yVn71XCCaNgxz58ERTl8nA/8YYtIQDY9mHSrgFBfiFtdNNfY0h183Vh8BRkKxD8x9TUw3ec290uJKhDVxqGZBw==}
+    dependencies:
+      parents: 1.0.1
+    dev: true
+
+  /genversion@3.2.0:
+    resolution: {integrity: sha512-OIYSX6XYA8PHecLDCTri30hadSZfAjZ8Iq1+BBDXqLWP4dRLuJNLoNjsSWtTpw97IccK2LDWzkEstxAB8GdN7g==}
+    engines: {node: '>=10.0.0'}
+    hasBin: true
+    dependencies:
+      commander: 7.2.0
+      ejs: 3.1.9
+      find-package: 1.0.0
+    dev: true
+
+  /has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /jake@10.8.7:
+    resolution: {integrity: sha512-ZDi3aP+fG/LchyBzUM804VjddnwfSfsdeYkwt8NcbKRvo4rFkjhs456iLFn3k2ZUWvNe4i48WACDbza8fhq2+w==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      async: 3.2.5
+      chalk: 4.1.2
+      filelist: 1.0.4
+      minimatch: 3.1.2
+    dev: true
+
+  /minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+    dependencies:
+      brace-expansion: 1.1.11
+    dev: true
+
+  /minimatch@5.1.6:
+    resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==}
+    engines: {node: '>=10'}
+    dependencies:
+      brace-expansion: 2.0.1
+    dev: true
+
+  /ms@2.1.2:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+    dev: true
+
+  /parents@1.0.1:
+    resolution: {integrity: sha512-mXKF3xkoUt5td2DoxpLmtOmZvko9VfFpwRwkKDHSNvgmpLAeBo18YDhcPbBzJq+QLCHMbGOfzia2cX4U+0v9Mg==}
+    dependencies:
+      path-platform: 0.11.15
+    dev: true
+
+  /path-platform@0.11.15:
+    resolution: {integrity: sha512-Y30dB6rab1A/nfEKsZxmr01nUotHX0c/ZiIAsCTatEe1CmS5Pm5He7fZ195bPT7RdquoaL8lLxFCMQi/bS7IJg==}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+    dependencies:
+      has-flag: 4.0.0
+    dev: true
+
+  /typescript@4.5.2:
+    resolution: {integrity: sha512-5BlMof9H1yGt0P8/WF+wPNw6GfctgGjXp5hkblpyT+8rkASSmkUKMXrxR0Xg8ThVCi/JnHQiKXeBaEwCeQwMFw==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true

packages/js/src/gen/livekit_agent_pb.d.ts

@@ -0,0 +1,458 @@
+// 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.7.2 with parameter "target=js+dts"
+// @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 } from "@bufbuild/protobuf";
+import type { ParticipantInfo, Room } from "./livekit_models_pb.js";
+
+/**
+ * @generated from enum livekit.JobType
+ */
+export declare enum JobType {
+  /**
+   * @generated from enum value: JT_ROOM = 0;
+   */
+  JT_ROOM = 0,
+
+  /**
+   * @generated from enum value: JT_PUBLISHER = 1;
+   */
+  JT_PUBLISHER = 1,
+}
+
+/**
+ * @generated from enum livekit.WorkerStatus
+ */
+export declare enum WorkerStatus {
+  /**
+   * @generated from enum value: WS_AVAILABLE = 0;
+   */
+  WS_AVAILABLE = 0,
+
+  /**
+   * @generated from enum value: WS_FULL = 1;
+   */
+  WS_FULL = 1,
+}
+
+/**
+ * @generated from enum livekit.JobStatus
+ */
+export declare enum JobStatus {
+  /**
+   * @generated from enum value: JS_UNKNOWN = 0;
+   */
+  JS_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: JS_SUCCESS = 1;
+   */
+  JS_SUCCESS = 1,
+
+  /**
+   * @generated from enum value: JS_FAILED = 2;
+   */
+  JS_FAILED = 2,
+}
+
+/**
+ * @generated from message livekit.AgentInfo
+ */
+export declare class AgentInfo extends Message<AgentInfo> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id: string;
+
+  /**
+   * @generated from field: string name = 2;
+   */
+  name: string;
+
+  /**
+   * @generated from field: string version = 3;
+   */
+  version: string;
+
+  constructor(data?: PartialMessage<AgentInfo>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.AgentInfo";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentInfo;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentInfo;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentInfo;
+
+  static equals(a: AgentInfo | PlainMessage<AgentInfo> | undefined, b: AgentInfo | PlainMessage<AgentInfo> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.Job
+ */
+export declare class Job extends Message<Job> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id: string;
+
+  /**
+   * @generated from field: livekit.JobType type = 2;
+   */
+  type: JobType;
+
+  /**
+   * @generated from field: livekit.Room room = 3;
+   */
+  room?: Room;
+
+  /**
+   * @generated from field: optional livekit.ParticipantInfo participant = 4;
+   */
+  participant?: ParticipantInfo;
+
+  constructor(data?: PartialMessage<Job>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.Job";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Job;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Job;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Job;
+
+  static equals(a: Job | PlainMessage<Job> | undefined, b: Job | PlainMessage<Job> | undefined): boolean;
+}
+
+/**
+ * from Worker to Server
+ *
+ * @generated from message livekit.WorkerMessage
+ */
+export declare class WorkerMessage extends Message<WorkerMessage> {
+  /**
+   * @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 status = 3;
+     */
+    value: UpdateWorkerStatus;
+    case: "status";
+  } | {
+    /**
+     * @generated from field: livekit.JobStatusUpdate job_update = 4;
+     */
+    value: JobStatusUpdate;
+    case: "jobUpdate";
+  } | { case: undefined; value?: undefined };
+
+  constructor(data?: PartialMessage<WorkerMessage>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.WorkerMessage";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WorkerMessage;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WorkerMessage;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WorkerMessage;
+
+  static equals(a: WorkerMessage | PlainMessage<WorkerMessage> | undefined, b: WorkerMessage | PlainMessage<WorkerMessage> | undefined): boolean;
+}
+
+/**
+ * from Server to Worker
+ *
+ * @generated from message livekit.ServerMessage
+ */
+export declare class ServerMessage extends Message<ServerMessage> {
+  /**
+   * @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";
+  } | { case: undefined; value?: undefined };
+
+  constructor(data?: PartialMessage<ServerMessage>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ServerMessage";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage;
+
+  static equals(a: ServerMessage | PlainMessage<ServerMessage> | undefined, b: ServerMessage | PlainMessage<ServerMessage> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.RegisterWorkerRequest
+ */
+export declare class RegisterWorkerRequest extends Message<RegisterWorkerRequest> {
+  /**
+   * @generated from field: livekit.JobType type = 1;
+   */
+  type: JobType;
+
+  /**
+   * @generated from field: string worker_id = 2;
+   */
+  workerId: string;
+
+  /**
+   * @generated from field: string version = 3;
+   */
+  version: string;
+
+  /**
+   * @generated from field: string name = 4;
+   */
+  name: string;
+
+  constructor(data?: PartialMessage<RegisterWorkerRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.RegisterWorkerRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterWorkerRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterWorkerRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterWorkerRequest;
+
+  static equals(a: RegisterWorkerRequest | PlainMessage<RegisterWorkerRequest> | undefined, b: RegisterWorkerRequest | PlainMessage<RegisterWorkerRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.RegisterWorkerResponse
+ */
+export declare class RegisterWorkerResponse extends Message<RegisterWorkerResponse> {
+  /**
+   * @generated from field: string worker_id = 1;
+   */
+  workerId: string;
+
+  /**
+   * @generated from field: string server_version = 2;
+   */
+  serverVersion: string;
+
+  constructor(data?: PartialMessage<RegisterWorkerResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.RegisterWorkerResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterWorkerResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterWorkerResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterWorkerResponse;
+
+  static equals(a: RegisterWorkerResponse | PlainMessage<RegisterWorkerResponse> | undefined, b: RegisterWorkerResponse | PlainMessage<RegisterWorkerResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.AvailabilityRequest
+ */
+export declare class AvailabilityRequest extends Message<AvailabilityRequest> {
+  /**
+   * @generated from field: livekit.Job job = 1;
+   */
+  job?: Job;
+
+  constructor(data?: PartialMessage<AvailabilityRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.AvailabilityRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AvailabilityRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AvailabilityRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AvailabilityRequest;
+
+  static equals(a: AvailabilityRequest | PlainMessage<AvailabilityRequest> | undefined, b: AvailabilityRequest | PlainMessage<AvailabilityRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.AvailabilityResponse
+ */
+export declare class AvailabilityResponse extends Message<AvailabilityResponse> {
+  /**
+   * @generated from field: string job_id = 1;
+   */
+  jobId: string;
+
+  /**
+   * @generated from field: bool available = 2;
+   */
+  available: boolean;
+
+  constructor(data?: PartialMessage<AvailabilityResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.AvailabilityResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AvailabilityResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+
+  static equals(a: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined, b: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.JobStatusUpdate
+ */
+export declare class JobStatusUpdate extends Message<JobStatusUpdate> {
+  /**
+   * @generated from field: string job_id = 1;
+   */
+  jobId: string;
+
+  /**
+   * @generated from field: livekit.JobStatus status = 2;
+   */
+  status: JobStatus;
+
+  /**
+   * @generated from field: string error = 3;
+   */
+  error: string;
+
+  /**
+   * @generated from field: string user_data = 4;
+   */
+  userData: string;
+
+  constructor(data?: PartialMessage<JobStatusUpdate>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.JobStatusUpdate";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobStatusUpdate;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobStatusUpdate;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobStatusUpdate;
+
+  static equals(a: JobStatusUpdate | PlainMessage<JobStatusUpdate> | undefined, b: JobStatusUpdate | PlainMessage<JobStatusUpdate> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.JobAssignment
+ */
+export declare class JobAssignment extends Message<JobAssignment> {
+  /**
+   * @generated from field: livekit.Job job = 1;
+   */
+  job?: Job;
+
+  constructor(data?: PartialMessage<JobAssignment>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.JobAssignment";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobAssignment;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobAssignment;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobAssignment;
+
+  static equals(a: JobAssignment | PlainMessage<JobAssignment> | undefined, b: JobAssignment | PlainMessage<JobAssignment> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.UpdateWorkerStatus
+ */
+export declare class UpdateWorkerStatus extends Message<UpdateWorkerStatus> {
+  /**
+   * @generated from field: livekit.WorkerStatus status = 1;
+   */
+  status: WorkerStatus;
+
+  constructor(data?: PartialMessage<UpdateWorkerStatus>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.UpdateWorkerStatus";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateWorkerStatus;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
+
+  static equals(a: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined, b: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined): boolean;
+}
+

packages/js/src/gen/livekit_agent_pb.js

@@ -0,0 +1,188 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_agent.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+import { ParticipantInfo, Room } from "./livekit_models_pb.js";
+
+/**
+ * @generated from enum livekit.JobType
+ */
+export const JobType = proto3.makeEnum(
+  "livekit.JobType",
+  [
+    {no: 0, name: "JT_ROOM"},
+    {no: 1, name: "JT_PUBLISHER"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.WorkerStatus
+ */
+export const WorkerStatus = proto3.makeEnum(
+  "livekit.WorkerStatus",
+  [
+    {no: 0, name: "WS_AVAILABLE"},
+    {no: 1, name: "WS_FULL"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.JobStatus
+ */
+export const JobStatus = proto3.makeEnum(
+  "livekit.JobStatus",
+  [
+    {no: 0, name: "JS_UNKNOWN"},
+    {no: 1, name: "JS_SUCCESS"},
+    {no: 2, name: "JS_FAILED"},
+  ],
+);
+
+/**
+ * @generated from message livekit.AgentInfo
+ */
+export const AgentInfo = proto3.makeMessageType(
+  "livekit.AgentInfo",
+  () => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.Job
+ */
+export const Job = proto3.makeMessageType(
+  "livekit.Job",
+  () => [
+    { no: 1, name: "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 },
+  ],
+);
+
+/**
+ * from Worker to Server
+ *
+ * @generated from message livekit.WorkerMessage
+ */
+export const WorkerMessage = proto3.makeMessageType(
+  "livekit.WorkerMessage",
+  () => [
+    { no: 1, name: "register", kind: "message", T: RegisterWorkerRequest, oneof: "message" },
+    { no: 2, name: "availability", kind: "message", T: AvailabilityResponse, oneof: "message" },
+    { no: 3, name: "status", kind: "message", T: UpdateWorkerStatus, oneof: "message" },
+    { no: 4, name: "job_update", kind: "message", T: JobStatusUpdate, oneof: "message" },
+  ],
+);
+
+/**
+ * from Server to Worker
+ *
+ * @generated from message livekit.ServerMessage
+ */
+export const ServerMessage = proto3.makeMessageType(
+  "livekit.ServerMessage",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.RegisterWorkerRequest
+ */
+export const RegisterWorkerRequest = proto3.makeMessageType(
+  "livekit.RegisterWorkerRequest",
+  () => [
+    { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(JobType) },
+    { no: 2, name: "worker_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.RegisterWorkerResponse
+ */
+export const RegisterWorkerResponse = proto3.makeMessageType(
+  "livekit.RegisterWorkerResponse",
+  () => [
+    { no: 1, name: "worker_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "server_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.AvailabilityRequest
+ */
+export const AvailabilityRequest = proto3.makeMessageType(
+  "livekit.AvailabilityRequest",
+  () => [
+    { no: 1, name: "job", kind: "message", T: Job },
+  ],
+);
+
+/**
+ * @generated from message livekit.AvailabilityResponse
+ */
+export const AvailabilityResponse = proto3.makeMessageType(
+  "livekit.AvailabilityResponse",
+  () => [
+    { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "available", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.JobStatusUpdate
+ */
+export const JobStatusUpdate = proto3.makeMessageType(
+  "livekit.JobStatusUpdate",
+  () => [
+    { 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 */ },
+    { no: 4, name: "user_data", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.JobAssignment
+ */
+export const JobAssignment = proto3.makeMessageType(
+  "livekit.JobAssignment",
+  () => [
+    { no: 1, name: "job", kind: "message", T: Job },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateWorkerStatus
+ */
+export const UpdateWorkerStatus = proto3.makeMessageType(
+  "livekit.UpdateWorkerStatus",
+  () => [
+    { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(WorkerStatus) },
+  ],
+);
+

packages/js/src/gen/livekit_egress_pb.js

@@ -0,0 +1,572 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_egress.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+import { AudioCodec, ImageCodec, VideoCodec } from "./livekit_models_pb.js";
+
+/**
+ * @generated from enum livekit.EncodedFileType
+ */
+export const EncodedFileType = proto3.makeEnum(
+  "livekit.EncodedFileType",
+  [
+    {no: 0, name: "DEFAULT_FILETYPE"},
+    {no: 1, name: "MP4"},
+    {no: 2, name: "OGG"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.SegmentedFileProtocol
+ */
+export const SegmentedFileProtocol = proto3.makeEnum(
+  "livekit.SegmentedFileProtocol",
+  [
+    {no: 0, name: "DEFAULT_SEGMENTED_FILE_PROTOCOL"},
+    {no: 1, name: "HLS_PROTOCOL"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.SegmentedFileSuffix
+ */
+export const SegmentedFileSuffix = proto3.makeEnum(
+  "livekit.SegmentedFileSuffix",
+  [
+    {no: 0, name: "INDEX"},
+    {no: 1, name: "TIMESTAMP"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.ImageFileSuffix
+ */
+export const ImageFileSuffix = proto3.makeEnum(
+  "livekit.ImageFileSuffix",
+  [
+    {no: 0, name: "IMAGE_SUFFIX_INDEX"},
+    {no: 1, name: "IMAGE_SUFFIX_TIMESTAMP"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.StreamProtocol
+ */
+export const StreamProtocol = proto3.makeEnum(
+  "livekit.StreamProtocol",
+  [
+    {no: 0, name: "DEFAULT_PROTOCOL"},
+    {no: 1, name: "RTMP"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.EncodingOptionsPreset
+ */
+export const EncodingOptionsPreset = proto3.makeEnum(
+  "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 const EgressStatus = proto3.makeEnum(
+  "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 const RoomCompositeEgressRequest = proto3.makeMessageType(
+  "livekit.RoomCompositeEgressRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * record any website
+ *
+ * @generated from message livekit.WebEgressRequest
+ */
+export const WebEgressRequest = proto3.makeMessageType(
+  "livekit.WebEgressRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * record audio and video from a single participant
+ *
+ * @generated from message livekit.ParticipantEgressRequest
+ */
+export const ParticipantEgressRequest = proto3.makeMessageType(
+  "livekit.ParticipantEgressRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * containerize up to one audio and one video track
+ *
+ * @generated from message livekit.TrackCompositeEgressRequest
+ */
+export const TrackCompositeEgressRequest = proto3.makeMessageType(
+  "livekit.TrackCompositeEgressRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * record tracks individually, without transcoding
+ *
+ * @generated from message livekit.TrackEgressRequest
+ */
+export const TrackEgressRequest = proto3.makeMessageType(
+  "livekit.TrackEgressRequest",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.EncodedFileOutput
+ */
+export const EncodedFileOutput = proto3.makeMessageType(
+  "livekit.EncodedFileOutput",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * Used to generate HLS segments or other kind of segmented output
+ *
+ * @generated from message livekit.SegmentedFileOutput
+ */
+export const SegmentedFileOutput = proto3.makeMessageType(
+  "livekit.SegmentedFileOutput",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.DirectFileOutput
+ */
+export const DirectFileOutput = proto3.makeMessageType(
+  "livekit.DirectFileOutput",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.ImageOutput
+ */
+export const ImageOutput = proto3.makeMessageType(
+  "livekit.ImageOutput",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.S3Upload
+ */
+export const S3Upload = proto3.makeMessageType(
+  "livekit.S3Upload",
+  () => [
+    { 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 */ },
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.GCPUpload
+ */
+export const GCPUpload = proto3.makeMessageType(
+  "livekit.GCPUpload",
+  () => [
+    { no: 1, name: "credentials", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "bucket", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.AzureBlobUpload
+ */
+export const AzureBlobUpload = proto3.makeMessageType(
+  "livekit.AzureBlobUpload",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.AliOSSUpload
+ */
+export const AliOSSUpload = proto3.makeMessageType(
+  "livekit.AliOSSUpload",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.StreamOutput
+ */
+export const StreamOutput = proto3.makeMessageType(
+  "livekit.StreamOutput",
+  () => [
+    { no: 1, name: "protocol", kind: "enum", T: proto3.getEnumType(StreamProtocol) },
+    { no: 2, name: "urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.EncodingOptions
+ */
+export const EncodingOptions = proto3.makeMessageType(
+  "livekit.EncodingOptions",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateLayoutRequest
+ */
+export const UpdateLayoutRequest = proto3.makeMessageType(
+  "livekit.UpdateLayoutRequest",
+  () => [
+    { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "layout", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateStreamRequest
+ */
+export const UpdateStreamRequest = proto3.makeMessageType(
+  "livekit.UpdateStreamRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListEgressRequest
+ */
+export const ListEgressRequest = proto3.makeMessageType(
+  "livekit.ListEgressRequest",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListEgressResponse
+ */
+export const ListEgressResponse = proto3.makeMessageType(
+  "livekit.ListEgressResponse",
+  () => [
+    { no: 1, name: "items", kind: "message", T: EgressInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.StopEgressRequest
+ */
+export const StopEgressRequest = proto3.makeMessageType(
+  "livekit.StopEgressRequest",
+  () => [
+    { no: 1, name: "egress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.EgressInfo
+ */
+export const EgressInfo = proto3.makeMessageType(
+  "livekit.EgressInfo",
+  () => [
+    { 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: 9, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.StreamInfoList
+ * @deprecated
+ */
+export const StreamInfoList = proto3.makeMessageType(
+  "livekit.StreamInfoList",
+  () => [
+    { no: 1, name: "info", kind: "message", T: StreamInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.StreamInfo
+ */
+export const StreamInfo = proto3.makeMessageType(
+  "livekit.StreamInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from enum livekit.StreamInfo.Status
+ */
+export const StreamInfo_Status = proto3.makeEnum(
+  "livekit.StreamInfo.Status",
+  [
+    {no: 0, name: "ACTIVE"},
+    {no: 1, name: "FINISHED"},
+    {no: 2, name: "FAILED"},
+  ],
+);
+
+/**
+ * @generated from message livekit.FileInfo
+ */
+export const FileInfo = proto3.makeMessageType(
+  "livekit.FileInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SegmentsInfo
+ */
+export const SegmentsInfo = proto3.makeMessageType(
+  "livekit.SegmentsInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ImagesInfo
+ */
+export const ImagesInfo = proto3.makeMessageType(
+  "livekit.ImagesInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.AutoParticipantEgress
+ */
+export const AutoParticipantEgress = proto3.makeMessageType(
+  "livekit.AutoParticipantEgress",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.AutoTrackEgress
+ */
+export const AutoTrackEgress = proto3.makeMessageType(
+  "livekit.AutoTrackEgress",
+  () => [
+    { 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" },
+  ],
+);
+

packages/js/src/gen/livekit_ingress_pb.d.ts

@@ -0,0 +1,818 @@
+// 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.7.2 with parameter "target=js+dts"
+// @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 } from "@bufbuild/protobuf";
+import type { AudioCodec, TrackInfo, TrackSource, VideoCodec, VideoLayer } from "./livekit_models_pb.js";
+
+/**
+ * @generated from enum livekit.IngressInput
+ */
+export declare 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,
+}
+
+/**
+ * @generated from enum livekit.IngressAudioEncodingPreset
+ */
+export declare 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,
+}
+
+/**
+ * @generated from enum livekit.IngressVideoEncodingPreset
+ */
+export declare 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,
+}
+
+/**
+ * @generated from message livekit.CreateIngressRequest
+ */
+export declare class CreateIngressRequest extends Message<CreateIngressRequest> {
+  /**
+   * @generated from field: livekit.IngressInput input_type = 1;
+   */
+  inputType: IngressInput;
+
+  /**
+   * Where to pull media from, only for URL input type
+   *
+   * @generated from field: string url = 9;
+   */
+  url: string;
+
+  /**
+   * User provided identifier for the ingress
+   *
+   * @generated from field: string name = 2;
+   */
+  name: string;
+
+  /**
+   * room to publish to
+   *
+   * @generated from field: string room_name = 3;
+   */
+  roomName: string;
+
+  /**
+   * publish as participant
+   *
+   * @generated from field: string participant_identity = 4;
+   */
+  participantIdentity: string;
+
+  /**
+   * name of publishing participant (used for display only)
+   *
+   * @generated from field: string participant_name = 5;
+   */
+  participantName: string;
+
+  /**
+   * metadata associated with the publishing participant
+   *
+   * @generated from field: string participant_metadata = 10;
+   */
+  participantMetadata: string;
+
+  /**
+   * whether to pass through the incoming media without transcoding, only compatible with some input types
+   *
+   * @generated from field: bool bypass_transcoding = 8;
+   */
+  bypassTranscoding: boolean;
+
+  /**
+   * @generated from field: livekit.IngressAudioOptions audio = 6;
+   */
+  audio?: IngressAudioOptions;
+
+  /**
+   * @generated from field: livekit.IngressVideoOptions video = 7;
+   */
+  video?: IngressVideoOptions;
+
+  constructor(data?: PartialMessage<CreateIngressRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.CreateIngressRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateIngressRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateIngressRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateIngressRequest;
+
+  static equals(a: CreateIngressRequest | PlainMessage<CreateIngressRequest> | undefined, b: CreateIngressRequest | PlainMessage<CreateIngressRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressAudioOptions
+ */
+export declare class IngressAudioOptions extends Message<IngressAudioOptions> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name: string;
+
+  /**
+   * @generated from field: livekit.TrackSource source = 2;
+   */
+  source: TrackSource;
+
+  /**
+   * @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 };
+
+  constructor(data?: PartialMessage<IngressAudioOptions>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressAudioOptions";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressAudioOptions;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressAudioOptions;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressAudioOptions;
+
+  static equals(a: IngressAudioOptions | PlainMessage<IngressAudioOptions> | undefined, b: IngressAudioOptions | PlainMessage<IngressAudioOptions> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressVideoOptions
+ */
+export declare class IngressVideoOptions extends Message<IngressVideoOptions> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name: string;
+
+  /**
+   * @generated from field: livekit.TrackSource source = 2;
+   */
+  source: TrackSource;
+
+  /**
+   * @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 };
+
+  constructor(data?: PartialMessage<IngressVideoOptions>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressVideoOptions";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressVideoOptions;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressVideoOptions;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressVideoOptions;
+
+  static equals(a: IngressVideoOptions | PlainMessage<IngressVideoOptions> | undefined, b: IngressVideoOptions | PlainMessage<IngressVideoOptions> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressAudioEncodingOptions
+ */
+export declare class IngressAudioEncodingOptions extends Message<IngressAudioEncodingOptions> {
+  /**
+   * desired audio codec to publish to room
+   *
+   * @generated from field: livekit.AudioCodec audio_codec = 1;
+   */
+  audioCodec: AudioCodec;
+
+  /**
+   * @generated from field: uint32 bitrate = 2;
+   */
+  bitrate: number;
+
+  /**
+   * @generated from field: bool disable_dtx = 3;
+   */
+  disableDtx: boolean;
+
+  /**
+   * @generated from field: uint32 channels = 4;
+   */
+  channels: number;
+
+  constructor(data?: PartialMessage<IngressAudioEncodingOptions>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressAudioEncodingOptions";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressAudioEncodingOptions;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressAudioEncodingOptions;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressAudioEncodingOptions;
+
+  static equals(a: IngressAudioEncodingOptions | PlainMessage<IngressAudioEncodingOptions> | undefined, b: IngressAudioEncodingOptions | PlainMessage<IngressAudioEncodingOptions> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressVideoEncodingOptions
+ */
+export declare class IngressVideoEncodingOptions extends Message<IngressVideoEncodingOptions> {
+  /**
+   * desired codec to publish to room
+   *
+   * @generated from field: livekit.VideoCodec video_codec = 1;
+   */
+  videoCodec: VideoCodec;
+
+  /**
+   * @generated from field: double frame_rate = 2;
+   */
+  frameRate: number;
+
+  /**
+   * 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<IngressVideoEncodingOptions>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressVideoEncodingOptions";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressVideoEncodingOptions;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressVideoEncodingOptions;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressVideoEncodingOptions;
+
+  static equals(a: IngressVideoEncodingOptions | PlainMessage<IngressVideoEncodingOptions> | undefined, b: IngressVideoEncodingOptions | PlainMessage<IngressVideoEncodingOptions> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressInfo
+ */
+export declare class IngressInfo extends Message<IngressInfo> {
+  /**
+   * @generated from field: string ingress_id = 1;
+   */
+  ingressId: string;
+
+  /**
+   * @generated from field: string name = 2;
+   */
+  name: string;
+
+  /**
+   * @generated from field: string stream_key = 3;
+   */
+  streamKey: string;
+
+  /**
+   * 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: string;
+
+  /**
+   * 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;
+
+  /**
+   * @generated from field: bool bypass_transcoding = 13;
+   */
+  bypassTranscoding: 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: string;
+
+  /**
+   * @generated from field: string participant_identity = 9;
+   */
+  participantIdentity: string;
+
+  /**
+   * @generated from field: string participant_name = 10;
+   */
+  participantName: string;
+
+  /**
+   * @generated from field: string participant_metadata = 14;
+   */
+  participantMetadata: string;
+
+  /**
+   * @generated from field: bool reusable = 11;
+   */
+  reusable: boolean;
+
+  /**
+   * 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<IngressInfo>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressInfo";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressInfo;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressInfo;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressInfo;
+
+  static equals(a: IngressInfo | PlainMessage<IngressInfo> | undefined, b: IngressInfo | PlainMessage<IngressInfo> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.IngressState
+ */
+export declare class IngressState extends Message<IngressState> {
+  /**
+   * @generated from field: livekit.IngressState.Status status = 1;
+   */
+  status: IngressState_Status;
+
+  /**
+   * Error/non compliance description if any
+   *
+   * @generated from field: string error = 2;
+   */
+  error: string;
+
+  /**
+   * @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: string;
+
+  /**
+   * @generated from field: int64 started_at = 7;
+   */
+  startedAt: bigint;
+
+  /**
+   * @generated from field: int64 ended_at = 8;
+   */
+  endedAt: bigint;
+
+  /**
+   * @generated from field: string resource_id = 9;
+   */
+  resourceId: string;
+
+  /**
+   * @generated from field: repeated livekit.TrackInfo tracks = 6;
+   */
+  tracks: TrackInfo[];
+
+  constructor(data?: PartialMessage<IngressState>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.IngressState";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IngressState;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IngressState;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IngressState;
+
+  static equals(a: IngressState | PlainMessage<IngressState> | undefined, b: IngressState | PlainMessage<IngressState> | undefined): boolean;
+}
+
+/**
+ * @generated from enum livekit.IngressState.Status
+ */
+export declare 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,
+}
+
+/**
+ * @generated from message livekit.InputVideoState
+ */
+export declare class InputVideoState extends Message<InputVideoState> {
+  /**
+   * @generated from field: string mime_type = 1;
+   */
+  mimeType: string;
+
+  /**
+   * @generated from field: uint32 average_bitrate = 2;
+   */
+  averageBitrate: number;
+
+  /**
+   * @generated from field: uint32 width = 3;
+   */
+  width: number;
+
+  /**
+   * @generated from field: uint32 height = 4;
+   */
+  height: number;
+
+  /**
+   * @generated from field: double framerate = 5;
+   */
+  framerate: number;
+
+  constructor(data?: PartialMessage<InputVideoState>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.InputVideoState";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InputVideoState;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InputVideoState;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InputVideoState;
+
+  static equals(a: InputVideoState | PlainMessage<InputVideoState> | undefined, b: InputVideoState | PlainMessage<InputVideoState> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.InputAudioState
+ */
+export declare class InputAudioState extends Message<InputAudioState> {
+  /**
+   * @generated from field: string mime_type = 1;
+   */
+  mimeType: string;
+
+  /**
+   * @generated from field: uint32 average_bitrate = 2;
+   */
+  averageBitrate: number;
+
+  /**
+   * @generated from field: uint32 channels = 3;
+   */
+  channels: number;
+
+  /**
+   * @generated from field: uint32 sample_rate = 4;
+   */
+  sampleRate: number;
+
+  constructor(data?: PartialMessage<InputAudioState>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.InputAudioState";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InputAudioState;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InputAudioState;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InputAudioState;
+
+  static equals(a: InputAudioState | PlainMessage<InputAudioState> | undefined, b: InputAudioState | PlainMessage<InputAudioState> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.UpdateIngressRequest
+ */
+export declare class UpdateIngressRequest extends Message<UpdateIngressRequest> {
+  /**
+   * @generated from field: string ingress_id = 1;
+   */
+  ingressId: string;
+
+  /**
+   * @generated from field: string name = 2;
+   */
+  name: string;
+
+  /**
+   * @generated from field: string room_name = 3;
+   */
+  roomName: string;
+
+  /**
+   * @generated from field: string participant_identity = 4;
+   */
+  participantIdentity: string;
+
+  /**
+   * @generated from field: string participant_name = 5;
+   */
+  participantName: string;
+
+  /**
+   * @generated from field: string participant_metadata = 9;
+   */
+  participantMetadata: string;
+
+  /**
+   * @generated from field: optional bool bypass_transcoding = 8;
+   */
+  bypassTranscoding?: boolean;
+
+  /**
+   * @generated from field: livekit.IngressAudioOptions audio = 6;
+   */
+  audio?: IngressAudioOptions;
+
+  /**
+   * @generated from field: livekit.IngressVideoOptions video = 7;
+   */
+  video?: IngressVideoOptions;
+
+  constructor(data?: PartialMessage<UpdateIngressRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.UpdateIngressRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateIngressRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateIngressRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateIngressRequest;
+
+  static equals(a: UpdateIngressRequest | PlainMessage<UpdateIngressRequest> | undefined, b: UpdateIngressRequest | PlainMessage<UpdateIngressRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListIngressRequest
+ */
+export declare class ListIngressRequest extends Message<ListIngressRequest> {
+  /**
+   * when blank, lists all ingress endpoints
+   *
+   * (optional, filter by room name)
+   *
+   * @generated from field: string room_name = 1;
+   */
+  roomName: string;
+
+  /**
+   * (optional, filter by ingress ID)
+   *
+   * @generated from field: string ingress_id = 2;
+   */
+  ingressId: string;
+
+  constructor(data?: PartialMessage<ListIngressRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListIngressRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListIngressRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListIngressRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListIngressRequest;
+
+  static equals(a: ListIngressRequest | PlainMessage<ListIngressRequest> | undefined, b: ListIngressRequest | PlainMessage<ListIngressRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListIngressResponse
+ */
+export declare class ListIngressResponse extends Message<ListIngressResponse> {
+  /**
+   * @generated from field: repeated livekit.IngressInfo items = 1;
+   */
+  items: IngressInfo[];
+
+  constructor(data?: PartialMessage<ListIngressResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListIngressResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListIngressResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListIngressResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListIngressResponse;
+
+  static equals(a: ListIngressResponse | PlainMessage<ListIngressResponse> | undefined, b: ListIngressResponse | PlainMessage<ListIngressResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.DeleteIngressRequest
+ */
+export declare class DeleteIngressRequest extends Message<DeleteIngressRequest> {
+  /**
+   * @generated from field: string ingress_id = 1;
+   */
+  ingressId: string;
+
+  constructor(data?: PartialMessage<DeleteIngressRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.DeleteIngressRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteIngressRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteIngressRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteIngressRequest;
+
+  static equals(a: DeleteIngressRequest | PlainMessage<DeleteIngressRequest> | undefined, b: DeleteIngressRequest | PlainMessage<DeleteIngressRequest> | undefined): boolean;
+}
+

packages/js/src/gen/livekit_ingress_pb.js

@@ -0,0 +1,265 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_ingress.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+import { AudioCodec, TrackInfo, TrackSource, VideoCodec, VideoLayer } from "./livekit_models_pb.js";
+
+/**
+ * @generated from enum livekit.IngressInput
+ */
+export const IngressInput = proto3.makeEnum(
+  "livekit.IngressInput",
+  [
+    {no: 0, name: "RTMP_INPUT"},
+    {no: 1, name: "WHIP_INPUT"},
+    {no: 2, name: "URL_INPUT"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.IngressAudioEncodingPreset
+ */
+export const IngressAudioEncodingPreset = proto3.makeEnum(
+  "livekit.IngressAudioEncodingPreset",
+  [
+    {no: 0, name: "OPUS_STEREO_96KBPS"},
+    {no: 1, name: "OPUS_MONO_64KBS"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.IngressVideoEncodingPreset
+ */
+export const IngressVideoEncodingPreset = proto3.makeEnum(
+  "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 const CreateIngressRequest = proto3.makeMessageType(
+  "livekit.CreateIngressRequest",
+  () => [
+    { 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: 6, name: "audio", kind: "message", T: IngressAudioOptions },
+    { no: 7, name: "video", kind: "message", T: IngressVideoOptions },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressAudioOptions
+ */
+export const IngressAudioOptions = proto3.makeMessageType(
+  "livekit.IngressAudioOptions",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressVideoOptions
+ */
+export const IngressVideoOptions = proto3.makeMessageType(
+  "livekit.IngressVideoOptions",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressAudioEncodingOptions
+ */
+export const IngressAudioEncodingOptions = proto3.makeMessageType(
+  "livekit.IngressAudioEncodingOptions",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressVideoEncodingOptions
+ */
+export const IngressVideoEncodingOptions = proto3.makeMessageType(
+  "livekit.IngressVideoEncodingOptions",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressInfo
+ */
+export const IngressInfo = proto3.makeMessageType(
+  "livekit.IngressInfo",
+  () => [
+    { 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: 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.IngressState
+ */
+export const IngressState = proto3.makeMessageType(
+  "livekit.IngressState",
+  () => [
+    { 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: 9, name: "resource_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "tracks", kind: "message", T: TrackInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from enum livekit.IngressState.Status
+ */
+export const IngressState_Status = proto3.makeEnum(
+  "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 const InputVideoState = proto3.makeMessageType(
+  "livekit.InputVideoState",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.InputAudioState
+ */
+export const InputAudioState = proto3.makeMessageType(
+  "livekit.InputAudioState",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateIngressRequest
+ */
+export const UpdateIngressRequest = proto3.makeMessageType(
+  "livekit.UpdateIngressRequest",
+  () => [
+    { 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: 6, name: "audio", kind: "message", T: IngressAudioOptions },
+    { no: 7, name: "video", kind: "message", T: IngressVideoOptions },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListIngressRequest
+ */
+export const ListIngressRequest = proto3.makeMessageType(
+  "livekit.ListIngressRequest",
+  () => [
+    { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListIngressResponse
+ */
+export const ListIngressResponse = proto3.makeMessageType(
+  "livekit.ListIngressResponse",
+  () => [
+    { no: 1, name: "items", kind: "message", T: IngressInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.DeleteIngressRequest
+ */
+export const DeleteIngressRequest = proto3.makeMessageType(
+  "livekit.DeleteIngressRequest",
+  () => [
+    { no: 1, name: "ingress_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+

packages/js/src/gen/livekit_models_pb.js

@@ -0,0 +1,612 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_models.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3, Timestamp } from "@bufbuild/protobuf";
+
+/**
+ * @generated from enum livekit.AudioCodec
+ */
+export const AudioCodec = proto3.makeEnum(
+  "livekit.AudioCodec",
+  [
+    {no: 0, name: "DEFAULT_AC"},
+    {no: 1, name: "OPUS"},
+    {no: 2, name: "AAC"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.VideoCodec
+ */
+export const VideoCodec = proto3.makeEnum(
+  "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 const ImageCodec = proto3.makeEnum(
+  "livekit.ImageCodec",
+  [
+    {no: 0, name: "IC_DEFAULT"},
+    {no: 1, name: "IC_JPEG"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.TrackType
+ */
+export const TrackType = proto3.makeEnum(
+  "livekit.TrackType",
+  [
+    {no: 0, name: "AUDIO"},
+    {no: 1, name: "VIDEO"},
+    {no: 2, name: "DATA"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.TrackSource
+ */
+export const TrackSource = proto3.makeEnum(
+  "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 const VideoQuality = proto3.makeEnum(
+  "livekit.VideoQuality",
+  [
+    {no: 0, name: "LOW"},
+    {no: 1, name: "MEDIUM"},
+    {no: 2, name: "HIGH"},
+    {no: 3, name: "OFF"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.ConnectionQuality
+ */
+export const ConnectionQuality = proto3.makeEnum(
+  "livekit.ConnectionQuality",
+  [
+    {no: 0, name: "POOR"},
+    {no: 1, name: "GOOD"},
+    {no: 2, name: "EXCELLENT"},
+    {no: 3, name: "LOST"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.ClientConfigSetting
+ */
+export const ClientConfigSetting = proto3.makeEnum(
+  "livekit.ClientConfigSetting",
+  [
+    {no: 0, name: "UNSET"},
+    {no: 1, name: "DISABLED"},
+    {no: 2, name: "ENABLED"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.DisconnectReason
+ */
+export const DisconnectReason = proto3.makeEnum(
+  "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"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.ReconnectReason
+ */
+export const ReconnectReason = proto3.makeEnum(
+  "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 const SubscriptionError = proto3.makeEnum(
+  "livekit.SubscriptionError",
+  [
+    {no: 0, name: "SE_UNKNOWN"},
+    {no: 1, name: "SE_CODEC_UNSUPPORTED"},
+    {no: 2, name: "SE_TRACK_NOTFOUND"},
+  ],
+);
+
+/**
+ * @generated from message livekit.Room
+ */
+export const Room = proto3.makeMessageType(
+  "livekit.Room",
+  () => [
+    { 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: 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.Codec
+ */
+export const Codec = proto3.makeMessageType(
+  "livekit.Codec",
+  () => [
+    { no: 1, name: "mime", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "fmtp_line", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.PlayoutDelay
+ */
+export const PlayoutDelay = proto3.makeMessageType(
+  "livekit.PlayoutDelay",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ParticipantPermission
+ */
+export const ParticipantPermission = proto3.makeMessageType(
+  "livekit.ParticipantPermission",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ParticipantInfo
+ */
+export const ParticipantInfo = proto3.makeMessageType(
+  "livekit.ParticipantInfo",
+  () => [
+    { 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) },
+  ],
+);
+
+/**
+ * @generated from enum livekit.ParticipantInfo.State
+ */
+export const ParticipantInfo_State = proto3.makeEnum(
+  "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 const ParticipantInfo_Kind = proto3.makeEnum(
+  "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 const Encryption = proto3.makeMessageType(
+  "livekit.Encryption",
+  [],
+);
+
+/**
+ * @generated from enum livekit.Encryption.Type
+ */
+export const Encryption_Type = proto3.makeEnum(
+  "livekit.Encryption.Type",
+  [
+    {no: 0, name: "NONE"},
+    {no: 1, name: "GCM"},
+    {no: 2, name: "CUSTOM"},
+  ],
+);
+
+/**
+ * @generated from message livekit.SimulcastCodecInfo
+ */
+export const SimulcastCodecInfo = proto3.makeMessageType(
+  "livekit.SimulcastCodecInfo",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.TrackInfo
+ */
+export const TrackInfo = proto3.makeMessageType(
+  "livekit.TrackInfo",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * provide information about available spatial layers
+ *
+ * @generated from message livekit.VideoLayer
+ */
+export const VideoLayer = proto3.makeMessageType(
+  "livekit.VideoLayer",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * new DataPacket API
+ *
+ * @generated from message livekit.DataPacket
+ */
+export const DataPacket = proto3.makeMessageType(
+  "livekit.DataPacket",
+  () => [
+    { no: 1, name: "kind", kind: "enum", T: proto3.getEnumType(DataPacket_Kind) },
+    { no: 2, name: "user", kind: "message", T: UserPacket, oneof: "value" },
+    { no: 3, name: "speaker", kind: "message", T: ActiveSpeakerUpdate, oneof: "value" },
+  ],
+);
+
+/**
+ * @generated from enum livekit.DataPacket.Kind
+ */
+export const DataPacket_Kind = proto3.makeEnum(
+  "livekit.DataPacket.Kind",
+  [
+    {no: 0, name: "RELIABLE"},
+    {no: 1, name: "LOSSY"},
+  ],
+);
+
+/**
+ * @generated from message livekit.ActiveSpeakerUpdate
+ */
+export const ActiveSpeakerUpdate = proto3.makeMessageType(
+  "livekit.ActiveSpeakerUpdate",
+  () => [
+    { no: 1, name: "speakers", kind: "message", T: SpeakerInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.SpeakerInfo
+ */
+export const SpeakerInfo = proto3.makeMessageType(
+  "livekit.SpeakerInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.UserPacket
+ */
+export const UserPacket = proto3.makeMessageType(
+  "livekit.UserPacket",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.ParticipantTracks
+ */
+export const ParticipantTracks = proto3.makeMessageType(
+  "livekit.ParticipantTracks",
+  () => [
+    { no: 1, name: "participant_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ],
+);
+
+/**
+ * details about the server
+ *
+ * @generated from message livekit.ServerInfo
+ */
+export const ServerInfo = proto3.makeMessageType(
+  "livekit.ServerInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from enum livekit.ServerInfo.Edition
+ */
+export const ServerInfo_Edition = proto3.makeEnum(
+  "livekit.ServerInfo.Edition",
+  [
+    {no: 0, name: "Standard"},
+    {no: 1, name: "Cloud"},
+  ],
+);
+
+/**
+ * details about the client
+ *
+ * @generated from message livekit.ClientInfo
+ */
+export const ClientInfo = proto3.makeMessageType(
+  "livekit.ClientInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from enum livekit.ClientInfo.SDK
+ */
+export const ClientInfo_SDK = proto3.makeEnum(
+  "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"},
+  ],
+);
+
+/**
+ * server provided client configuration
+ *
+ * @generated from message livekit.ClientConfiguration
+ */
+export const ClientConfiguration = proto3.makeMessageType(
+  "livekit.ClientConfiguration",
+  () => [
+    { 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) },
+  ],
+);
+
+/**
+ * @generated from message livekit.VideoConfiguration
+ */
+export const VideoConfiguration = proto3.makeMessageType(
+  "livekit.VideoConfiguration",
+  () => [
+    { no: 1, name: "hardware_encoder", kind: "enum", T: proto3.getEnumType(ClientConfigSetting) },
+  ],
+);
+
+/**
+ * @generated from message livekit.DisabledCodecs
+ */
+export const DisabledCodecs = proto3.makeMessageType(
+  "livekit.DisabledCodecs",
+  () => [
+    { no: 1, name: "codecs", kind: "message", T: Codec, repeated: true },
+    { no: 2, name: "publish", kind: "message", T: Codec, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.RTPDrift
+ */
+export const RTPDrift = proto3.makeMessageType(
+  "livekit.RTPDrift",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.RTPStats
+ */
+export const RTPStats = proto3.makeMessageType(
+  "livekit.RTPStats",
+  () => [
+    { 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: "report_drift", kind: "message", T: RTPDrift },
+  ],
+);
+
+/**
+ * @generated from message livekit.TimedVersion
+ */
+export const TimedVersion = proto3.makeMessageType(
+  "livekit.TimedVersion",
+  () => [
+    { no: 1, name: "unix_micro", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 2, name: "ticks", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+  ],
+);
+

packages/js/src/gen/livekit_rtc_pb.js

@@ -0,0 +1,565 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_rtc.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+import { ClientConfiguration, 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 const SignalTarget = proto3.makeEnum(
+  "livekit.SignalTarget",
+  [
+    {no: 0, name: "PUBLISHER"},
+    {no: 1, name: "SUBSCRIBER"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.StreamState
+ */
+export const StreamState = proto3.makeEnum(
+  "livekit.StreamState",
+  [
+    {no: 0, name: "ACTIVE"},
+    {no: 1, name: "PAUSED"},
+  ],
+);
+
+/**
+ * @generated from enum livekit.CandidateProtocol
+ */
+export const CandidateProtocol = proto3.makeEnum(
+  "livekit.CandidateProtocol",
+  [
+    {no: 0, name: "UDP"},
+    {no: 1, name: "TCP"},
+    {no: 2, name: "TLS"},
+  ],
+);
+
+/**
+ * @generated from message livekit.SignalRequest
+ */
+export const SignalRequest = proto3.makeMessageType(
+  "livekit.SignalRequest",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.SignalResponse
+ */
+export const SignalResponse = proto3.makeMessageType(
+  "livekit.SignalResponse",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.SimulcastCodec
+ */
+export const SimulcastCodec = proto3.makeMessageType(
+  "livekit.SimulcastCodec",
+  () => [
+    { no: 1, name: "codec", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.AddTrackRequest
+ */
+export const AddTrackRequest = proto3.makeMessageType(
+  "livekit.AddTrackRequest",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.TrickleRequest
+ */
+export const TrickleRequest = proto3.makeMessageType(
+  "livekit.TrickleRequest",
+  () => [
+    { no: 1, name: "candidateInit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "target", kind: "enum", T: proto3.getEnumType(SignalTarget) },
+  ],
+);
+
+/**
+ * @generated from message livekit.MuteTrackRequest
+ */
+export const MuteTrackRequest = proto3.makeMessageType(
+  "livekit.MuteTrackRequest",
+  () => [
+    { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.JoinResponse
+ */
+export const JoinResponse = proto3.makeMessageType(
+  "livekit.JoinResponse",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ReconnectResponse
+ */
+export const ReconnectResponse = proto3.makeMessageType(
+  "livekit.ReconnectResponse",
+  () => [
+    { no: 1, name: "ice_servers", kind: "message", T: ICEServer, repeated: true },
+    { no: 2, name: "client_configuration", kind: "message", T: ClientConfiguration },
+  ],
+);
+
+/**
+ * @generated from message livekit.TrackPublishedResponse
+ */
+export const TrackPublishedResponse = proto3.makeMessageType(
+  "livekit.TrackPublishedResponse",
+  () => [
+    { no: 1, name: "cid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "track", kind: "message", T: TrackInfo },
+  ],
+);
+
+/**
+ * @generated from message livekit.TrackUnpublishedResponse
+ */
+export const TrackUnpublishedResponse = proto3.makeMessageType(
+  "livekit.TrackUnpublishedResponse",
+  () => [
+    { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SessionDescription
+ */
+export const SessionDescription = proto3.makeMessageType(
+  "livekit.SessionDescription",
+  () => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "sdp", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ParticipantUpdate
+ */
+export const ParticipantUpdate = proto3.makeMessageType(
+  "livekit.ParticipantUpdate",
+  () => [
+    { no: 1, name: "participants", kind: "message", T: ParticipantInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateSubscription
+ */
+export const UpdateSubscription = proto3.makeMessageType(
+  "livekit.UpdateSubscription",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateTrackSettings
+ */
+export const UpdateTrackSettings = proto3.makeMessageType(
+  "livekit.UpdateTrackSettings",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.LeaveRequest
+ */
+export const LeaveRequest = proto3.makeMessageType(
+  "livekit.LeaveRequest",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * indicates action clients should take on receiving this message
+ *
+ * @generated from enum livekit.LeaveRequest.Action
+ */
+export const LeaveRequest_Action = proto3.makeEnum(
+  "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
+ */
+export const UpdateVideoLayers = proto3.makeMessageType(
+  "livekit.UpdateVideoLayers",
+  () => [
+    { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "layers", kind: "message", T: VideoLayer, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.UpdateParticipantMetadata
+ */
+export const UpdateParticipantMetadata = proto3.makeMessageType(
+  "livekit.UpdateParticipantMetadata",
+  () => [
+    { no: 1, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ICEServer
+ */
+export const ICEServer = proto3.makeMessageType(
+  "livekit.ICEServer",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SpeakersChanged
+ */
+export const SpeakersChanged = proto3.makeMessageType(
+  "livekit.SpeakersChanged",
+  () => [
+    { no: 1, name: "speakers", kind: "message", T: SpeakerInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.RoomUpdate
+ */
+export const RoomUpdate = proto3.makeMessageType(
+  "livekit.RoomUpdate",
+  () => [
+    { no: 1, name: "room", kind: "message", T: Room },
+  ],
+);
+
+/**
+ * @generated from message livekit.ConnectionQualityInfo
+ */
+export const ConnectionQualityInfo = proto3.makeMessageType(
+  "livekit.ConnectionQualityInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ConnectionQualityUpdate
+ */
+export const ConnectionQualityUpdate = proto3.makeMessageType(
+  "livekit.ConnectionQualityUpdate",
+  () => [
+    { no: 1, name: "updates", kind: "message", T: ConnectionQualityInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.StreamStateInfo
+ */
+export const StreamStateInfo = proto3.makeMessageType(
+  "livekit.StreamStateInfo",
+  () => [
+    { 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) },
+  ],
+);
+
+/**
+ * @generated from message livekit.StreamStateUpdate
+ */
+export const StreamStateUpdate = proto3.makeMessageType(
+  "livekit.StreamStateUpdate",
+  () => [
+    { no: 1, name: "stream_states", kind: "message", T: StreamStateInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscribedQuality
+ */
+export const SubscribedQuality = proto3.makeMessageType(
+  "livekit.SubscribedQuality",
+  () => [
+    { no: 1, name: "quality", kind: "enum", T: proto3.getEnumType(VideoQuality) },
+    { no: 2, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscribedCodec
+ */
+export const SubscribedCodec = proto3.makeMessageType(
+  "livekit.SubscribedCodec",
+  () => [
+    { no: 1, name: "codec", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "qualities", kind: "message", T: SubscribedQuality, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscribedQualityUpdate
+ */
+export const SubscribedQualityUpdate = proto3.makeMessageType(
+  "livekit.SubscribedQualityUpdate",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.TrackPermission
+ */
+export const TrackPermission = proto3.makeMessageType(
+  "livekit.TrackPermission",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscriptionPermission
+ */
+export const SubscriptionPermission = proto3.makeMessageType(
+  "livekit.SubscriptionPermission",
+  () => [
+    { no: 1, name: "all_participants", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "track_permissions", kind: "message", T: TrackPermission, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscriptionPermissionUpdate
+ */
+export const SubscriptionPermissionUpdate = proto3.makeMessageType(
+  "livekit.SubscriptionPermissionUpdate",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SyncState
+ */
+export const SyncState = proto3.makeMessageType(
+  "livekit.SyncState",
+  () => [
+    { 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 },
+  ],
+);
+
+/**
+ * @generated from message livekit.DataChannelInfo
+ */
+export const DataChannelInfo = proto3.makeMessageType(
+  "livekit.DataChannelInfo",
+  () => [
+    { 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) },
+  ],
+);
+
+/**
+ * @generated from message livekit.SimulateScenario
+ */
+export const SimulateScenario = proto3.makeMessageType(
+  "livekit.SimulateScenario",
+  () => [
+    { 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" },
+  ],
+);
+
+/**
+ * @generated from message livekit.Ping
+ */
+export const Ping = proto3.makeMessageType(
+  "livekit.Ping",
+  () => [
+    { no: 1, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 2, name: "rtt", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.Pong
+ */
+export const Pong = proto3.makeMessageType(
+  "livekit.Pong",
+  () => [
+    { no: 1, name: "last_ping_timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 2, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.RegionSettings
+ */
+export const RegionSettings = proto3.makeMessageType(
+  "livekit.RegionSettings",
+  () => [
+    { no: 1, name: "regions", kind: "message", T: RegionInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.RegionInfo
+ */
+export const RegionInfo = proto3.makeMessageType(
+  "livekit.RegionInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SubscriptionResponse
+ */
+export const SubscriptionResponse = proto3.makeMessageType(
+  "livekit.SubscriptionResponse",
+  () => [
+    { no: 1, name: "track_sid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "err", kind: "enum", T: proto3.getEnumType(SubscriptionError) },
+  ],
+);
+

packages/js/src/gen/livekit_sip_pb.d.ts

@@ -0,0 +1,578 @@
+// 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.7.2 with parameter "target=js+dts"
+// @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 { Message, proto3 } from "@bufbuild/protobuf";
+
+/**
+ * @generated from message livekit.CreateSIPTrunkRequest
+ */
+export declare class CreateSIPTrunkRequest extends Message<CreateSIPTrunkRequest> {
+  /**
+   * 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: string;
+
+  /**
+   * Number used to make outbound calls
+   *
+   * @generated from field: string outbound_number = 3;
+   */
+  outboundNumber: 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_regex = 4;
+   */
+  inboundNumbersRegex: 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: string;
+
+  /**
+   * @generated from field: string inbound_password = 6;
+   */
+  inboundPassword: string;
+
+  /**
+   * @generated from field: string outbound_username = 7;
+   */
+  outboundUsername: string;
+
+  /**
+   * @generated from field: string outbound_password = 8;
+   */
+  outboundPassword: string;
+
+  constructor(data?: PartialMessage<CreateSIPTrunkRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.CreateSIPTrunkRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateSIPTrunkRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateSIPTrunkRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateSIPTrunkRequest;
+
+  static equals(a: CreateSIPTrunkRequest | PlainMessage<CreateSIPTrunkRequest> | undefined, b: CreateSIPTrunkRequest | PlainMessage<CreateSIPTrunkRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPTrunkInfo
+ */
+export declare class SIPTrunkInfo extends Message<SIPTrunkInfo> {
+  /**
+   * @generated from field: string sip_trunk_id = 1;
+   */
+  sipTrunkId: string;
+
+  /**
+   * 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: string;
+
+  /**
+   * Number used to make outbound calls
+   *
+   * @generated from field: string outbound_number = 4;
+   */
+  outboundNumber: 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_regex = 5;
+   */
+  inboundNumbersRegex: 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: string;
+
+  /**
+   * @generated from field: string inbound_password = 7;
+   */
+  inboundPassword: string;
+
+  /**
+   * @generated from field: string outbound_username = 8;
+   */
+  outboundUsername: string;
+
+  /**
+   * @generated from field: string outbound_password = 9;
+   */
+  outboundPassword: string;
+
+  constructor(data?: PartialMessage<SIPTrunkInfo>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPTrunkInfo";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPTrunkInfo;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPTrunkInfo;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPTrunkInfo;
+
+  static equals(a: SIPTrunkInfo | PlainMessage<SIPTrunkInfo> | undefined, b: SIPTrunkInfo | PlainMessage<SIPTrunkInfo> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListSIPTrunkRequest
+ */
+export declare class ListSIPTrunkRequest extends Message<ListSIPTrunkRequest> {
+  constructor(data?: PartialMessage<ListSIPTrunkRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListSIPTrunkRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListSIPTrunkRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListSIPTrunkRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListSIPTrunkRequest;
+
+  static equals(a: ListSIPTrunkRequest | PlainMessage<ListSIPTrunkRequest> | undefined, b: ListSIPTrunkRequest | PlainMessage<ListSIPTrunkRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListSIPTrunkResponse
+ */
+export declare class ListSIPTrunkResponse extends Message<ListSIPTrunkResponse> {
+  /**
+   * @generated from field: repeated livekit.SIPTrunkInfo items = 1;
+   */
+  items: SIPTrunkInfo[];
+
+  constructor(data?: PartialMessage<ListSIPTrunkResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListSIPTrunkResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListSIPTrunkResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListSIPTrunkResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListSIPTrunkResponse;
+
+  static equals(a: ListSIPTrunkResponse | PlainMessage<ListSIPTrunkResponse> | undefined, b: ListSIPTrunkResponse | PlainMessage<ListSIPTrunkResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.DeleteSIPTrunkRequest
+ */
+export declare class DeleteSIPTrunkRequest extends Message<DeleteSIPTrunkRequest> {
+  /**
+   * @generated from field: string sip_trunk_id = 1;
+   */
+  sipTrunkId: string;
+
+  constructor(data?: PartialMessage<DeleteSIPTrunkRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.DeleteSIPTrunkRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteSIPTrunkRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteSIPTrunkRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteSIPTrunkRequest;
+
+  static equals(a: DeleteSIPTrunkRequest | PlainMessage<DeleteSIPTrunkRequest> | undefined, b: DeleteSIPTrunkRequest | PlainMessage<DeleteSIPTrunkRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPDispatchRuleDirect
+ */
+export declare class SIPDispatchRuleDirect extends Message<SIPDispatchRuleDirect> {
+  /**
+   * What room should call be directed into
+   *
+   * @generated from field: string room_name = 1;
+   */
+  roomName: string;
+
+  /**
+   * Optional pin required to enter room
+   *
+   * @generated from field: string pin = 2;
+   */
+  pin: string;
+
+  constructor(data?: PartialMessage<SIPDispatchRuleDirect>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPDispatchRuleDirect";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPDispatchRuleDirect;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPDispatchRuleDirect;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPDispatchRuleDirect;
+
+  static equals(a: SIPDispatchRuleDirect | PlainMessage<SIPDispatchRuleDirect> | undefined, b: SIPDispatchRuleDirect | PlainMessage<SIPDispatchRuleDirect> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPDispatchRuleIndividual
+ */
+export declare class SIPDispatchRuleIndividual extends Message<SIPDispatchRuleIndividual> {
+  /**
+   * Prefix used on new room name
+   *
+   * @generated from field: string room_prefix = 1;
+   */
+  roomPrefix: string;
+
+  /**
+   * Optional pin required to enter room
+   *
+   * @generated from field: string pin = 2;
+   */
+  pin: string;
+
+  constructor(data?: PartialMessage<SIPDispatchRuleIndividual>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPDispatchRuleIndividual";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPDispatchRuleIndividual;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPDispatchRuleIndividual;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPDispatchRuleIndividual;
+
+  static equals(a: SIPDispatchRuleIndividual | PlainMessage<SIPDispatchRuleIndividual> | undefined, b: SIPDispatchRuleIndividual | PlainMessage<SIPDispatchRuleIndividual> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPDispatchRule
+ */
+export declare class SIPDispatchRule extends Message<SIPDispatchRule> {
+  /**
+   * @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";
+  } | { case: undefined; value?: undefined };
+
+  constructor(data?: PartialMessage<SIPDispatchRule>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPDispatchRule";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPDispatchRule;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPDispatchRule;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPDispatchRule;
+
+  static equals(a: SIPDispatchRule | PlainMessage<SIPDispatchRule> | undefined, b: SIPDispatchRule | PlainMessage<SIPDispatchRule> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.CreateSIPDispatchRuleRequest
+ */
+export declare class CreateSIPDispatchRuleRequest extends Message<CreateSIPDispatchRuleRequest> {
+  /**
+   * @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 as the participant identity
+   * If true a random value will be used instead
+   *
+   * @generated from field: bool hide_phone_number = 3;
+   */
+  hidePhoneNumber: boolean;
+
+  constructor(data?: PartialMessage<CreateSIPDispatchRuleRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.CreateSIPDispatchRuleRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateSIPDispatchRuleRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateSIPDispatchRuleRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateSIPDispatchRuleRequest;
+
+  static equals(a: CreateSIPDispatchRuleRequest | PlainMessage<CreateSIPDispatchRuleRequest> | undefined, b: CreateSIPDispatchRuleRequest | PlainMessage<CreateSIPDispatchRuleRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPDispatchRuleInfo
+ */
+export declare class SIPDispatchRuleInfo extends Message<SIPDispatchRuleInfo> {
+  /**
+   * @generated from field: string sip_dispatch_rule_id = 1;
+   */
+  sipDispatchRuleId: string;
+
+  /**
+   * @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: boolean;
+
+  constructor(data?: PartialMessage<SIPDispatchRuleInfo>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPDispatchRuleInfo";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPDispatchRuleInfo;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPDispatchRuleInfo;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPDispatchRuleInfo;
+
+  static equals(a: SIPDispatchRuleInfo | PlainMessage<SIPDispatchRuleInfo> | undefined, b: SIPDispatchRuleInfo | PlainMessage<SIPDispatchRuleInfo> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListSIPDispatchRuleRequest
+ */
+export declare class ListSIPDispatchRuleRequest extends Message<ListSIPDispatchRuleRequest> {
+  constructor(data?: PartialMessage<ListSIPDispatchRuleRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListSIPDispatchRuleRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListSIPDispatchRuleRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListSIPDispatchRuleRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListSIPDispatchRuleRequest;
+
+  static equals(a: ListSIPDispatchRuleRequest | PlainMessage<ListSIPDispatchRuleRequest> | undefined, b: ListSIPDispatchRuleRequest | PlainMessage<ListSIPDispatchRuleRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.ListSIPDispatchRuleResponse
+ */
+export declare class ListSIPDispatchRuleResponse extends Message<ListSIPDispatchRuleResponse> {
+  /**
+   * @generated from field: repeated livekit.SIPDispatchRuleInfo items = 1;
+   */
+  items: SIPDispatchRuleInfo[];
+
+  constructor(data?: PartialMessage<ListSIPDispatchRuleResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.ListSIPDispatchRuleResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListSIPDispatchRuleResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListSIPDispatchRuleResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListSIPDispatchRuleResponse;
+
+  static equals(a: ListSIPDispatchRuleResponse | PlainMessage<ListSIPDispatchRuleResponse> | undefined, b: ListSIPDispatchRuleResponse | PlainMessage<ListSIPDispatchRuleResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.DeleteSIPDispatchRuleRequest
+ */
+export declare class DeleteSIPDispatchRuleRequest extends Message<DeleteSIPDispatchRuleRequest> {
+  /**
+   * @generated from field: string sip_dispatch_rule_id = 1;
+   */
+  sipDispatchRuleId: string;
+
+  constructor(data?: PartialMessage<DeleteSIPDispatchRuleRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.DeleteSIPDispatchRuleRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteSIPDispatchRuleRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteSIPDispatchRuleRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteSIPDispatchRuleRequest;
+
+  static equals(a: DeleteSIPDispatchRuleRequest | PlainMessage<DeleteSIPDispatchRuleRequest> | undefined, b: DeleteSIPDispatchRuleRequest | PlainMessage<DeleteSIPDispatchRuleRequest> | undefined): boolean;
+}
+
+/**
+ * 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 declare class CreateSIPParticipantRequest extends Message<CreateSIPParticipantRequest> {
+  /**
+   * What SIP Trunk should be used to dial the user
+   *
+   * @generated from field: string sip_trunk_id = 1;
+   */
+  sipTrunkId: string;
+
+  /**
+   * What number should be dialed via SIP
+   *
+   * @generated from field: string sip_call_to = 2;
+   */
+  sipCallTo: string;
+
+  /**
+   * What LiveKit room should this participant be connected too
+   *
+   * @generated from field: string room_name = 3;
+   */
+  roomName: string;
+
+  /**
+   * Optional identity of the participant in LiveKit room
+   *
+   * @generated from field: string participant_identity = 4;
+   */
+  participantIdentity: string;
+
+  constructor(data?: PartialMessage<CreateSIPParticipantRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.CreateSIPParticipantRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateSIPParticipantRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateSIPParticipantRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateSIPParticipantRequest;
+
+  static equals(a: CreateSIPParticipantRequest | PlainMessage<CreateSIPParticipantRequest> | undefined, b: CreateSIPParticipantRequest | PlainMessage<CreateSIPParticipantRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.SIPParticipantInfo
+ */
+export declare class SIPParticipantInfo extends Message<SIPParticipantInfo> {
+  /**
+   * @generated from field: string participant_id = 1;
+   */
+  participantId: string;
+
+  /**
+   * @generated from field: string participant_identity = 2;
+   */
+  participantIdentity: string;
+
+  /**
+   * @generated from field: string room_name = 3;
+   */
+  roomName: string;
+
+  constructor(data?: PartialMessage<SIPParticipantInfo>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SIPParticipantInfo";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SIPParticipantInfo;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SIPParticipantInfo;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SIPParticipantInfo;
+
+  static equals(a: SIPParticipantInfo | PlainMessage<SIPParticipantInfo> | undefined, b: SIPParticipantInfo | PlainMessage<SIPParticipantInfo> | undefined): boolean;
+}
+

packages/js/src/gen/livekit_sip_pb.js

@@ -0,0 +1,198 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_sip.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+
+/**
+ * @generated from message livekit.CreateSIPTrunkRequest
+ */
+export const CreateSIPTrunkRequest = proto3.makeMessageType(
+  "livekit.CreateSIPTrunkRequest",
+  () => [
+    { 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: 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPTrunkInfo
+ */
+export const SIPTrunkInfo = proto3.makeMessageType(
+  "livekit.SIPTrunkInfo",
+  () => [
+    { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { 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: 5, name: "inbound_numbers_regex", 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListSIPTrunkRequest
+ */
+export const ListSIPTrunkRequest = proto3.makeMessageType(
+  "livekit.ListSIPTrunkRequest",
+  [],
+);
+
+/**
+ * @generated from message livekit.ListSIPTrunkResponse
+ */
+export const ListSIPTrunkResponse = proto3.makeMessageType(
+  "livekit.ListSIPTrunkResponse",
+  () => [
+    { no: 1, name: "items", kind: "message", T: SIPTrunkInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.DeleteSIPTrunkRequest
+ */
+export const DeleteSIPTrunkRequest = proto3.makeMessageType(
+  "livekit.DeleteSIPTrunkRequest",
+  () => [
+    { no: 1, name: "sip_trunk_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPDispatchRuleDirect
+ */
+export const SIPDispatchRuleDirect = proto3.makeMessageType(
+  "livekit.SIPDispatchRuleDirect",
+  () => [
+    { no: 1, name: "room_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPDispatchRuleIndividual
+ */
+export const SIPDispatchRuleIndividual = proto3.makeMessageType(
+  "livekit.SIPDispatchRuleIndividual",
+  () => [
+    { no: 1, name: "room_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPDispatchRule
+ */
+export const SIPDispatchRule = proto3.makeMessageType(
+  "livekit.SIPDispatchRule",
+  () => [
+    { no: 1, name: "dispatch_rule_direct", kind: "message", T: SIPDispatchRuleDirect, oneof: "rule" },
+    { no: 2, name: "dispatch_rule_individual", kind: "message", T: SIPDispatchRuleIndividual, oneof: "rule" },
+  ],
+);
+
+/**
+ * @generated from message livekit.CreateSIPDispatchRuleRequest
+ */
+export const CreateSIPDispatchRuleRequest = proto3.makeMessageType(
+  "livekit.CreateSIPDispatchRuleRequest",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPDispatchRuleInfo
+ */
+export const SIPDispatchRuleInfo = proto3.makeMessageType(
+  "livekit.SIPDispatchRuleInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.ListSIPDispatchRuleRequest
+ */
+export const ListSIPDispatchRuleRequest = proto3.makeMessageType(
+  "livekit.ListSIPDispatchRuleRequest",
+  [],
+);
+
+/**
+ * @generated from message livekit.ListSIPDispatchRuleResponse
+ */
+export const ListSIPDispatchRuleResponse = proto3.makeMessageType(
+  "livekit.ListSIPDispatchRuleResponse",
+  () => [
+    { no: 1, name: "items", kind: "message", T: SIPDispatchRuleInfo, repeated: true },
+  ],
+);
+
+/**
+ * @generated from message livekit.DeleteSIPDispatchRuleRequest
+ */
+export const DeleteSIPDispatchRuleRequest = proto3.makeMessageType(
+  "livekit.DeleteSIPDispatchRuleRequest",
+  () => [
+    { no: 1, name: "sip_dispatch_rule_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+
+/**
+ * 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 const CreateSIPParticipantRequest = proto3.makeMessageType(
+  "livekit.CreateSIPParticipantRequest",
+  () => [
+    { 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 */ },
+  ],
+);
+
+/**
+ * @generated from message livekit.SIPParticipantInfo
+ */
+export const SIPParticipantInfo = proto3.makeMessageType(
+  "livekit.SIPParticipantInfo",
+  () => [
+    { 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 */ },
+  ],
+);
+

packages/js/src/gen/livekit_webhook_pb.d.ts

@@ -0,0 +1,105 @@
+// 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.7.2 with parameter "target=js+dts"
+// @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 } from "@bufbuild/protobuf";
+import type { ParticipantInfo, Room, TrackInfo } from "./livekit_models_pb.js";
+import type { EgressInfo } from "./livekit_egress_pb.js";
+import type { IngressInfo } from "./livekit_ingress_pb.js";
+
+/**
+ * @generated from message livekit.WebhookEvent
+ */
+export declare class WebhookEvent extends Message<WebhookEvent> {
+  /**
+   * 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: string;
+
+  /**
+   * @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: string;
+
+  /**
+   * timestamp in seconds
+   *
+   * @generated from field: int64 created_at = 7;
+   */
+  createdAt: bigint;
+
+  /**
+   * @generated from field: int32 num_dropped = 11;
+   */
+  numDropped: number;
+
+  constructor(data?: PartialMessage<WebhookEvent>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.WebhookEvent";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebhookEvent;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebhookEvent;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebhookEvent;
+
+  static equals(a: WebhookEvent | PlainMessage<WebhookEvent> | undefined, b: WebhookEvent | PlainMessage<WebhookEvent> | undefined): boolean;
+}
+

packages/js/src/gen/livekit_webhook_pb.js

@@ -0,0 +1,42 @@
+// 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.7.2 with parameter "target=js+dts"
+// @generated from file livekit_webhook.proto (package livekit, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } 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 const WebhookEvent = proto3.makeMessageType(
+  "livekit.WebhookEvent",
+  () => [
+    { 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 */ },
+  ],
+);
+

packages/js/src/gen/version.d.ts

@@ -0,0 +1 @@
+export declare const version: string;

packages/js/src/gen/version.js

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '13.0.0';

packages/js/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./gen/version.js";
+export * from "./gen/livekit_agent_pb.js";
+export * from "./gen/livekit_models_pb.js";
+export * from "./gen/livekit_rtc_pb.js";
+export * from "./gen/livekit_webhook_pb.js";
+export * from "./gen/livekit_egress.js";
+export * from "./gen/livekit_ingress.js";
+export * from "./gen/livekit_sip.js";

packages/js/src/index.js

@@ -0,0 +1,8 @@
+export * from "./gen/version.js";
+export * from "./gen/livekit_agent_pb.js";
+export * from "./gen/livekit_models_pb.js";
+export * from "./gen/livekit_rtc_pb.js";
+export * from "./gen/livekit_webhook_pb.js";
+export * from "./gen/livekit_egress.js";
+export * from "./gen/livekit_ingress.js";
+export * from "./gen/livekit_sip.js";