@stream-io/video-client 0.0.1-alpha.7

package/src/gen/video/coordinator/edge_v1/edge.ts

@@ -0,0 +1,532 @@
+/* eslint-disable */
+// @generated by protobuf-ts 2.8.1 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated from protobuf file "video/coordinator/edge_v1/edge.proto" (package "stream.video.coordinator.edge_v1", syntax proto3)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.Credentials
+ */
+export interface Credentials {
+    /**
+     * Edge server to connect to
+     *
+     * @generated from protobuf field: stream.video.coordinator.edge_v1.EdgeServer server = 1;
+     */
+    server?: EdgeServer;
+    /**
+     * The auth token needed to authenticate to the edge server
+     *
+     * @generated from protobuf field: string token = 2;
+     */
+    token: string;
+    /**
+     * The list of ICE servers
+     *
+     * @generated from protobuf field: repeated stream.video.coordinator.edge_v1.ICEServer ice_servers = 3;
+     */
+    iceServers: ICEServer[];
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.LatencyMeasurements
+ */
+export interface LatencyMeasurements {
+    /**
+     * @generated from protobuf field: map<string, stream.video.coordinator.edge_v1.Latency> measurements = 1;
+     */
+    measurements: {
+        [key: string]: Latency;
+    };
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.Latency
+ */
+export interface Latency {
+    /**
+     * @generated from protobuf field: repeated double measurements_seconds = 1;
+     */
+    measurementsSeconds: number[];
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.Coordinates
+ */
+export interface Coordinates {
+    /**
+     * @generated from protobuf field: float lat = 1;
+     */
+    lat: number;
+    /**
+     * @generated from protobuf field: float long = 2;
+     */
+    long: number;
+}
+/**
+ * Edges are where we deploy video servers
+ *
+ * @generated from protobuf message stream.video.coordinator.edge_v1.Edge
+ */
+export interface Edge {
+    /**
+     * @generated from protobuf field: string name = 1;
+     */
+    name: string;
+    /**
+     * @generated from protobuf field: string latency_url = 2;
+     */
+    latencyUrl: string;
+    /**
+     * @generated from protobuf field: stream.video.coordinator.edge_v1.Coordinates coordinates = 3;
+     */
+    coordinates?: Coordinates;
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.ICEServer
+ */
+export interface ICEServer {
+    /**
+     * @generated from protobuf field: repeated string urls = 1;
+     */
+    urls: string[];
+    /**
+     * @generated from protobuf field: string username = 2;
+     */
+    username: string;
+    /**
+     * @generated from protobuf field: string password = 3;
+     */
+    password: string;
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.edge_v1.EdgeServer
+ */
+export interface EdgeServer {
+    /**
+     * @generated from protobuf field: string url = 1;
+     */
+    url: string;
+    /**
+     * @generated from protobuf field: string edge_name = 2;
+     */
+    edgeName: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Credentials$Type extends MessageType<Credentials> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.Credentials", [
+            { no: 1, name: "server", kind: "message", T: () => EdgeServer, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
+            { no: 3, name: "ice_servers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ICEServer }
+        ]);
+    }
+    create(value?: PartialMessage<Credentials>): Credentials {
+        const message = { token: "", iceServers: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Credentials>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Credentials): Credentials {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* stream.video.coordinator.edge_v1.EdgeServer server */ 1:
+                    message.server = EdgeServer.internalBinaryRead(reader, reader.uint32(), options, message.server);
+                    break;
+                case /* string token */ 2:
+                    message.token = reader.string();
+                    break;
+                case /* repeated stream.video.coordinator.edge_v1.ICEServer ice_servers */ 3:
+                    message.iceServers.push(ICEServer.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Credentials, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* stream.video.coordinator.edge_v1.EdgeServer server = 1; */
+        if (message.server)
+            EdgeServer.internalBinaryWrite(message.server, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string token = 2; */
+        if (message.token !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.token);
+        /* repeated stream.video.coordinator.edge_v1.ICEServer ice_servers = 3; */
+        for (let i = 0; i < message.iceServers.length; i++)
+            ICEServer.internalBinaryWrite(message.iceServers[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Credentials
+ */
+export const Credentials = new Credentials$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LatencyMeasurements$Type extends MessageType<LatencyMeasurements> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.LatencyMeasurements", [
+            { no: 1, name: "measurements", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Latency } }
+        ]);
+    }
+    create(value?: PartialMessage<LatencyMeasurements>): LatencyMeasurements {
+        const message = { measurements: {} };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<LatencyMeasurements>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LatencyMeasurements): LatencyMeasurements {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* map<string, stream.video.coordinator.edge_v1.Latency> measurements */ 1:
+                    this.binaryReadMap1(message.measurements, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    private binaryReadMap1(map: LatencyMeasurements["measurements"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof LatencyMeasurements["measurements"] | undefined, val: LatencyMeasurements["measurements"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = Latency.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field stream.video.coordinator.edge_v1.LatencyMeasurements.measurements");
+            }
+        }
+        map[key ?? ""] = val ?? Latency.create();
+    }
+    internalBinaryWrite(message: LatencyMeasurements, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* map<string, stream.video.coordinator.edge_v1.Latency> measurements = 1; */
+        for (let k of Object.keys(message.measurements)) {
+            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            Latency.internalBinaryWrite(message.measurements[k], writer, options);
+            writer.join().join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.LatencyMeasurements
+ */
+export const LatencyMeasurements = new LatencyMeasurements$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Latency$Type extends MessageType<Latency> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.Latency", [
+            { no: 1, name: "measurements_seconds", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 1 /*ScalarType.DOUBLE*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Latency>): Latency {
+        const message = { measurementsSeconds: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Latency>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Latency): Latency {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated double measurements_seconds */ 1:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.measurementsSeconds.push(reader.double());
+                    else
+                        message.measurementsSeconds.push(reader.double());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Latency, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated double measurements_seconds = 1; */
+        if (message.measurementsSeconds.length) {
+            writer.tag(1, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.measurementsSeconds.length; i++)
+                writer.double(message.measurementsSeconds[i]);
+            writer.join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Latency
+ */
+export const Latency = new Latency$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Coordinates$Type extends MessageType<Coordinates> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.Coordinates", [
+            { no: 1, name: "lat", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "long", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Coordinates>): Coordinates {
+        const message = { lat: 0, long: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Coordinates>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Coordinates): Coordinates {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float lat */ 1:
+                    message.lat = reader.float();
+                    break;
+                case /* float long */ 2:
+                    message.long = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Coordinates, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* float lat = 1; */
+        if (message.lat !== 0)
+            writer.tag(1, WireType.Bit32).float(message.lat);
+        /* float long = 2; */
+        if (message.long !== 0)
+            writer.tag(2, WireType.Bit32).float(message.long);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Coordinates
+ */
+export const Coordinates = new Coordinates$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Edge$Type extends MessageType<Edge> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.Edge", [
+            { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
+            { no: 2, name: "latency_url", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
+            { no: 3, name: "coordinates", kind: "message", T: () => Coordinates }
+        ]);
+    }
+    create(value?: PartialMessage<Edge>): Edge {
+        const message = { name: "", latencyUrl: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Edge>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Edge): Edge {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string name */ 1:
+                    message.name = reader.string();
+                    break;
+                case /* string latency_url */ 2:
+                    message.latencyUrl = reader.string();
+                    break;
+                case /* stream.video.coordinator.edge_v1.Coordinates coordinates */ 3:
+                    message.coordinates = Coordinates.internalBinaryRead(reader, reader.uint32(), options, message.coordinates);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Edge, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string name = 1; */
+        if (message.name !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.name);
+        /* string latency_url = 2; */
+        if (message.latencyUrl !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.latencyUrl);
+        /* stream.video.coordinator.edge_v1.Coordinates coordinates = 3; */
+        if (message.coordinates)
+            Coordinates.internalBinaryWrite(message.coordinates, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Edge
+ */
+export const Edge = new Edge$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ICEServer$Type extends MessageType<ICEServer> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.ICEServer", [
+            { no: 1, name: "urls", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "username", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "password", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ICEServer>): ICEServer {
+        const message = { urls: [], username: "", password: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<ICEServer>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICEServer): ICEServer {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string urls */ 1:
+                    message.urls.push(reader.string());
+                    break;
+                case /* string username */ 2:
+                    message.username = reader.string();
+                    break;
+                case /* string password */ 3:
+                    message.password = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ICEServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string urls = 1; */
+        for (let i = 0; i < message.urls.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.urls[i]);
+        /* string username = 2; */
+        if (message.username !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.username);
+        /* string password = 3; */
+        if (message.password !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.password);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.ICEServer
+ */
+export const ICEServer = new ICEServer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EdgeServer$Type extends MessageType<EdgeServer> {
+    constructor() {
+        super("stream.video.coordinator.edge_v1.EdgeServer", [
+            { no: 1, name: "url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "edge_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<EdgeServer>): EdgeServer {
+        const message = { url: "", edgeName: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<EdgeServer>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EdgeServer): EdgeServer {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string url */ 1:
+                    message.url = reader.string();
+                    break;
+                case /* string edge_name */ 2:
+                    message.edgeName = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: EdgeServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string url = 1; */
+        if (message.url !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.url);
+        /* string edge_name = 2; */
+        if (message.edgeName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.edgeName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.EdgeServer
+ */
+export const EdgeServer = new EdgeServer$Type();