livekit-client 1.6.2 → 1.6.4

package/src/proto/livekit_models.ts

@@ -312,6 +312,8 @@ export interface ParticipantPermission {
   canPublish: boolean;
   /** allow participant to publish data */
   canPublishData: boolean;
+  /** sources that are allowed to be published */
+  canPublishSources: TrackSource[];
   /** indicates that it's hidden to others */
   hidden: boolean;
   /** indicates it's a recorder instance */
@@ -386,6 +388,48 @@ export function participantInfo_StateToJSON(object: ParticipantInfo_State): stri
   }
 }
 
+export interface Encryption {
+}
+
+export enum Encryption_Type {
+  NONE = 0,
+  GCM = 1,
+  CUSTOM = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function encryption_TypeFromJSON(object: any): Encryption_Type {
+  switch (object) {
+    case 0:
+    case "NONE":
+      return Encryption_Type.NONE;
+    case 1:
+    case "GCM":
+      return Encryption_Type.GCM;
+    case 2:
+    case "CUSTOM":
+      return Encryption_Type.CUSTOM;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Encryption_Type.UNRECOGNIZED;
+  }
+}
+
+export function encryption_TypeToJSON(object: Encryption_Type): string {
+  switch (object) {
+    case Encryption_Type.NONE:
+      return "NONE";
+    case Encryption_Type.GCM:
+      return "GCM";
+    case Encryption_Type.CUSTOM:
+      return "CUSTOM";
+    case Encryption_Type.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface SimulcastCodecInfo {
   mimeType: string;
   mid: string;
@@ -416,6 +460,10 @@ export interface TrackInfo {
   mimeType: string;
   mid: string;
   codecs: SimulcastCodecInfo[];
+  stereo: boolean;
+  /** true if RED (Redundant Encoding) is disabled for audio */
+  disableRed: boolean;
+  encryption: Encryption_Type;
 }
 
 /** provide information about available spatial layers */
@@ -424,7 +472,7 @@ export interface VideoLayer {
   quality: VideoQuality;
   width: number;
   height: number;
-  /** target bitrate, server will measure actual */
+  /** target bitrate in bit per second (bps), server will measure actual */
   bitrate: number;
   ssrc: number;
 }
@@ -894,7 +942,14 @@ export const Codec = {
 };
 
 function createBaseParticipantPermission(): ParticipantPermission {
-  return { canSubscribe: false, canPublish: false, canPublishData: false, hidden: false, recorder: false };
+  return {
+    canSubscribe: false,
+    canPublish: false,
+    canPublishData: false,
+    canPublishSources: [],
+    hidden: false,
+    recorder: false,
+  };
 }
 
 export const ParticipantPermission = {
@@ -908,6 +963,11 @@ export const ParticipantPermission = {
     if (message.canPublishData === true) {
       writer.uint32(24).bool(message.canPublishData);
     }
+    writer.uint32(74).fork();
+    for (const v of message.canPublishSources) {
+      writer.int32(v);
+    }
+    writer.ldelim();
     if (message.hidden === true) {
       writer.uint32(56).bool(message.hidden);
     }
@@ -933,6 +993,16 @@ export const ParticipantPermission = {
         case 3:
           message.canPublishData = reader.bool();
           break;
+        case 9:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.canPublishSources.push(reader.int32() as any);
+            }
+          } else {
+            message.canPublishSources.push(reader.int32() as any);
+          }
+          break;
         case 7:
           message.hidden = reader.bool();
           break;
@@ -952,6 +1022,9 @@ export const ParticipantPermission = {
       canSubscribe: isSet(object.canSubscribe) ? Boolean(object.canSubscribe) : false,
       canPublish: isSet(object.canPublish) ? Boolean(object.canPublish) : false,
       canPublishData: isSet(object.canPublishData) ? Boolean(object.canPublishData) : false,
+      canPublishSources: Array.isArray(object?.canPublishSources)
+        ? object.canPublishSources.map((e: any) => trackSourceFromJSON(e))
+        : [],
       hidden: isSet(object.hidden) ? Boolean(object.hidden) : false,
       recorder: isSet(object.recorder) ? Boolean(object.recorder) : false,
     };
@@ -962,6 +1035,11 @@ export const ParticipantPermission = {
     message.canSubscribe !== undefined && (obj.canSubscribe = message.canSubscribe);
     message.canPublish !== undefined && (obj.canPublish = message.canPublish);
     message.canPublishData !== undefined && (obj.canPublishData = message.canPublishData);
+    if (message.canPublishSources) {
+      obj.canPublishSources = message.canPublishSources.map((e) => trackSourceToJSON(e));
+    } else {
+      obj.canPublishSources = [];
+    }
     message.hidden !== undefined && (obj.hidden = message.hidden);
     message.recorder !== undefined && (obj.recorder = message.recorder);
     return obj;
@@ -972,6 +1050,7 @@ export const ParticipantPermission = {
     message.canSubscribe = object.canSubscribe ?? false;
     message.canPublish = object.canPublish ?? false;
     message.canPublishData = object.canPublishData ?? false;
+    message.canPublishSources = object.canPublishSources?.map((e) => e) || [];
     message.hidden = object.hidden ?? false;
     message.recorder = object.recorder ?? false;
     return message;
@@ -1136,6 +1215,45 @@ export const ParticipantInfo = {
   },
 };
 
+function createBaseEncryption(): Encryption {
+  return {};
+}
+
+export const Encryption = {
+  encode(_: Encryption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Encryption {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEncryption();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Encryption {
+    return {};
+  },
+
+  toJSON(_: Encryption): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Encryption>, I>>(_: I): Encryption {
+    const message = createBaseEncryption();
+    return message;
+  },
+};
+
 function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
   return { mimeType: "", mid: "", cid: "", layers: [] };
 }
@@ -1231,6 +1349,9 @@ function createBaseTrackInfo(): TrackInfo {
     mimeType: "",
     mid: "",
     codecs: [],
+    stereo: false,
+    disableRed: false,
+    encryption: 0,
   };
 }
 
@@ -1275,6 +1396,15 @@ export const TrackInfo = {
     for (const v of message.codecs) {
       SimulcastCodecInfo.encode(v!, writer.uint32(106).fork()).ldelim();
     }
+    if (message.stereo === true) {
+      writer.uint32(112).bool(message.stereo);
+    }
+    if (message.disableRed === true) {
+      writer.uint32(120).bool(message.disableRed);
+    }
+    if (message.encryption !== 0) {
+      writer.uint32(128).int32(message.encryption);
+    }
     return writer;
   },
 
@@ -1324,6 +1454,15 @@ export const TrackInfo = {
         case 13:
           message.codecs.push(SimulcastCodecInfo.decode(reader, reader.uint32()));
           break;
+        case 14:
+          message.stereo = reader.bool();
+          break;
+        case 15:
+          message.disableRed = reader.bool();
+          break;
+        case 16:
+          message.encryption = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1347,6 +1486,9 @@ export const TrackInfo = {
       mimeType: isSet(object.mimeType) ? String(object.mimeType) : "",
       mid: isSet(object.mid) ? String(object.mid) : "",
       codecs: Array.isArray(object?.codecs) ? object.codecs.map((e: any) => SimulcastCodecInfo.fromJSON(e)) : [],
+      stereo: isSet(object.stereo) ? Boolean(object.stereo) : false,
+      disableRed: isSet(object.disableRed) ? Boolean(object.disableRed) : false,
+      encryption: isSet(object.encryption) ? encryption_TypeFromJSON(object.encryption) : 0,
     };
   },
 
@@ -1373,6 +1515,9 @@ export const TrackInfo = {
     } else {
       obj.codecs = [];
     }
+    message.stereo !== undefined && (obj.stereo = message.stereo);
+    message.disableRed !== undefined && (obj.disableRed = message.disableRed);
+    message.encryption !== undefined && (obj.encryption = encryption_TypeToJSON(message.encryption));
     return obj;
   },
 
@@ -1391,6 +1536,9 @@ export const TrackInfo = {
     message.mimeType = object.mimeType ?? "";
     message.mid = object.mid ?? "";
     message.codecs = object.codecs?.map((e) => SimulcastCodecInfo.fromPartial(e)) || [];
+    message.stereo = object.stereo ?? false;
+    message.disableRed = object.disableRed ?? false;
+    message.encryption = object.encryption ?? 0;
     return message;
   },
 };
@@ -2825,7 +2973,7 @@ export const TimedVersion = {
 declare var self: any | undefined;
 declare var window: any | undefined;
 declare var global: any | undefined;
-var globalThis: any = (() => {
+var tsProtoGlobalThis: any = (() => {
   if (typeof globalThis !== "undefined") {
     return globalThis;
   }
@@ -2842,10 +2990,10 @@ var globalThis: any = (() => {
 })();
 
 function bytesFromBase64(b64: string): Uint8Array {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
   } else {
-    const bin = globalThis.atob(b64);
+    const bin = tsProtoGlobalThis.atob(b64);
     const arr = new Uint8Array(bin.length);
     for (let i = 0; i < bin.length; ++i) {
       arr[i] = bin.charCodeAt(i);
@@ -2855,14 +3003,14 @@ function bytesFromBase64(b64: string): Uint8Array {
 }
 
 function base64FromBytes(arr: Uint8Array): string {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
   } else {
     const bin: string[] = [];
     arr.forEach((byte) => {
       bin.push(String.fromCharCode(byte));
     });
-    return globalThis.btoa(bin.join(""));
+    return tsProtoGlobalThis.btoa(bin.join(""));
   }
 }
 
@@ -2902,7 +3050,7 @@ function fromJsonTimestamp(o: any): Date {
 
 function longToNumber(long: Long): number {
   if (long.gt(Number.MAX_SAFE_INTEGER)) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
   }
   return long.toNumber();
 }