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

package/dist/src/gen/video/coordinator/client_v1_rpc/envelopes.d.ts

@@ -0,0 +1,143 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Member } from "../member_v1/member";
+import { CallDetails } from "../call_v1/call";
+import { Call } from "../call_v1/call";
+import { User } from "../user_v1/user";
+/**
+ * CallEnvelope contains Call and all related information to it
+ * Only used in reponse types that return a single call
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.CallEnvelope
+ */
+export interface CallEnvelope {
+    /**
+     * All users referenced in the response
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.user_v1.User> users = 1;
+     */
+    users: {
+        [key: string]: User;
+    };
+    /**
+     * Call object
+     *
+     * @generated from protobuf field: stream.video.coordinator.call_v1.Call call = 2;
+     */
+    call?: Call;
+    /**
+     * Call details
+     *
+     * @generated from protobuf field: stream.video.coordinator.call_v1.CallDetails details = 3;
+     */
+    details?: CallDetails;
+}
+/**
+ * CallsEnvelope contains list of calls and all related information to them
+ * Only used in response types that return list of calls
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.CallsEnvelope
+ */
+export interface CallsEnvelope {
+    /**
+     * All users referenced in the response
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.user_v1.User> users = 1;
+     */
+    users: {
+        [key: string]: User;
+    };
+    /**
+     * Ordered list of Call.call_cid
+     *
+     * @generated from protobuf field: repeated string call_cids = 2;
+     */
+    callCids: string[];
+    /**
+     * Call objects, indexed by Call.call_cid
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.call_v1.Call> calls = 3;
+     */
+    calls: {
+        [key: string]: Call;
+    };
+    /**
+     * Call details, indexed by Call.call_cid
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.call_v1.CallDetails> details = 4;
+     */
+    details: {
+        [key: string]: CallDetails;
+    };
+}
+/**
+ * CallsEnvelope contains list of members and all related information to them
+ * Only used in response types that return list of members
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.MembersEnvelope
+ */
+export interface MembersEnvelope {
+    /**
+     * All users referenced in the response
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.user_v1.User> users = 1;
+     */
+    users: {
+        [key: string]: User;
+    };
+    /**
+     * Ordered list of Member.user_id
+     *
+     * @generated from protobuf field: repeated string member_user_ids = 2;
+     */
+    memberUserIds: string[];
+    /**
+     * Map of members indexed by Member.user_id
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.member_v1.Member> members = 3;
+     */
+    members: {
+        [key: string]: Member;
+    };
+}
+declare class CallEnvelope$Type extends MessageType<CallEnvelope> {
+    constructor();
+    create(value?: PartialMessage<CallEnvelope>): CallEnvelope;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CallEnvelope): CallEnvelope;
+    private binaryReadMap1;
+    internalBinaryWrite(message: CallEnvelope, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.CallEnvelope
+ */
+export declare const CallEnvelope: CallEnvelope$Type;
+declare class CallsEnvelope$Type extends MessageType<CallsEnvelope> {
+    constructor();
+    create(value?: PartialMessage<CallsEnvelope>): CallsEnvelope;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CallsEnvelope): CallsEnvelope;
+    private binaryReadMap1;
+    private binaryReadMap3;
+    private binaryReadMap4;
+    internalBinaryWrite(message: CallsEnvelope, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.CallsEnvelope
+ */
+export declare const CallsEnvelope: CallsEnvelope$Type;
+declare class MembersEnvelope$Type extends MessageType<MembersEnvelope> {
+    constructor();
+    create(value?: PartialMessage<MembersEnvelope>): MembersEnvelope;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MembersEnvelope): MembersEnvelope;
+    private binaryReadMap1;
+    private binaryReadMap3;
+    internalBinaryWrite(message: MembersEnvelope, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.MembersEnvelope
+ */
+export declare const MembersEnvelope: MembersEnvelope$Type;
+export {};

package/dist/src/gen/video/coordinator/client_v1_rpc/websocket.d.ts

@@ -0,0 +1,292 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { DeviceInput } from "../push_v1/push";
+import { UserInput } from "../user_v1/user";
+import { CallCustom } from "../event_v1/event";
+import { UserUpdated } from "../event_v1/event";
+import { CallCancelled } from "../event_v1/event";
+import { CallRejected } from "../event_v1/event";
+import { CallAccepted } from "../event_v1/event";
+import { CallEnded } from "../event_v1/event";
+import { CallMembersDeleted } from "../event_v1/event";
+import { CallMembersUpdated } from "../event_v1/event";
+import { CallMembersCreated } from "../event_v1/event";
+import { CallDeleted } from "../event_v1/event";
+import { CallUpdated } from "../event_v1/event";
+import { CallCreated } from "../event_v1/event";
+import { User } from "../user_v1/user";
+/**
+ * WebsocketEvent only includes events that are sent to the client via websocket connection
+ * This is not an exhaustive list of events, since not all of them are sent via websocket
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.WebsocketEvent
+ */
+export interface WebsocketEvent {
+    /**
+     * All users mentioned in the event payload, indexed by User.id
+     *
+     * @generated from protobuf field: map<string, stream.video.coordinator.user_v1.User> users = 1;
+     */
+    users: {
+        [key: string]: User;
+    };
+    /**
+     * @generated from protobuf oneof: event
+     */
+    event: {
+        oneofKind: "error";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.client_v1_rpc.WebsocketError error = 19;
+         */
+        error: WebsocketError;
+    } | {
+        oneofKind: "healthcheck";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.client_v1_rpc.WebsocketHealthcheck healthcheck = 20;
+         */
+        healthcheck: WebsocketHealthcheck;
+    } | {
+        oneofKind: "callCreated";
+        /**
+         * Call events
+         *
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallCreated call_created = 30;
+         */
+        callCreated: CallCreated;
+    } | {
+        oneofKind: "callUpdated";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallUpdated call_updated = 31;
+         */
+        callUpdated: CallUpdated;
+    } | {
+        oneofKind: "callDeleted";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallDeleted call_deleted = 32;
+         */
+        callDeleted: CallDeleted;
+    } | {
+        oneofKind: "callMembersCreated";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallMembersCreated call_members_created = 33;
+         */
+        callMembersCreated: CallMembersCreated;
+    } | {
+        oneofKind: "callMembersUpdated";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallMembersUpdated call_members_updated = 34;
+         */
+        callMembersUpdated: CallMembersUpdated;
+    } | {
+        oneofKind: "callMembersDeleted";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallMembersDeleted call_members_deleted = 35;
+         */
+        callMembersDeleted: CallMembersDeleted;
+    } | {
+        oneofKind: "callEnded";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallEnded call_ended = 36;
+         */
+        callEnded: CallEnded;
+    } | {
+        oneofKind: "callAccepted";
+        /**
+         * User initiated call events
+         *
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallAccepted call_accepted = 40;
+         */
+        callAccepted: CallAccepted;
+    } | {
+        oneofKind: "callRejected";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallRejected call_rejected = 41;
+         */
+        callRejected: CallRejected;
+    } | {
+        oneofKind: "callCancelled";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallCancelled call_cancelled = 42;
+         */
+        callCancelled: CallCancelled;
+    } | {
+        oneofKind: "userUpdated";
+        /**
+         * User events
+         *
+         * @generated from protobuf field: stream.video.coordinator.event_v1.UserUpdated user_updated = 50;
+         */
+        userUpdated: UserUpdated;
+    } | {
+        oneofKind: "callCustom";
+        /**
+         * Custom event
+         *
+         * @generated from protobuf field: stream.video.coordinator.event_v1.CallCustom call_custom = 99;
+         */
+        callCustom: CallCustom;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * WebsocketClientEvent contains all events that client is allowed to send to the server
+ * When clients sends any of mentioned events, they should be wrapped into ClientEvent
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.WebsocketClientEvent
+ */
+export interface WebsocketClientEvent {
+    /**
+     * @generated from protobuf oneof: event
+     */
+    event: {
+        oneofKind: "healthcheck";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.client_v1_rpc.WebsocketHealthcheck healthcheck = 1;
+         */
+        healthcheck: WebsocketHealthcheck;
+    } | {
+        oneofKind: "authRequest";
+        /**
+         * @generated from protobuf field: stream.video.coordinator.client_v1_rpc.WebsocketAuthRequest auth_request = 2;
+         */
+        authRequest: WebsocketAuthRequest;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * A payload that is sent through websocket to authenticate a connection
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.WebsocketAuthRequest
+ */
+export interface WebsocketAuthRequest {
+    /**
+     * Application API key that matches a secret is used to sign a token
+     *
+     * @generated from protobuf field: string api_key = 1;
+     */
+    apiKey: string;
+    /**
+     * A client JWT token
+     *
+     * @generated from protobuf field: string token = 2;
+     */
+    token: string;
+    /**
+     * Optional UserInput. When present, it is used to create or update user information.
+     * If contains some changes, a permission check will be performed
+     *
+     * @generated from protobuf field: stream.video.coordinator.user_v1.UserInput user = 3;
+     */
+    user?: UserInput;
+    /**
+     * Optional DeviceInput. When present, a device will be created for a user. If device
+     * already exists, nothing will happen
+     *
+     * @generated from protobuf field: stream.video.coordinator.push_v1.DeviceInput device = 4;
+     */
+    device?: DeviceInput;
+}
+/**
+ * Healthcheck is sent back and forth between websocket client and server
+ * When server sends a healthcheck, it is wrapped into WebsocketEvent
+ * When client sends healthcheck, it should be wrapped into WebsocketClientEvent
+ *
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.WebsocketHealthcheck
+ */
+export interface WebsocketHealthcheck {
+    /**
+     * @generated from protobuf field: string user_id = 1;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string client_id = 2;
+     */
+    clientId: string;
+    /**
+     * @generated from protobuf field: string call_type = 3;
+     */
+    callType: string;
+    /**
+     * @generated from protobuf field: string call_id = 4;
+     */
+    callId: string;
+    /**
+     * @generated from protobuf field: bool video = 5;
+     */
+    video: boolean;
+    /**
+     * @generated from protobuf field: bool audio = 6;
+     */
+    audio: boolean;
+}
+/**
+ * @generated from protobuf message stream.video.coordinator.client_v1_rpc.WebsocketError
+ */
+export interface WebsocketError {
+    /**
+     * @generated from protobuf field: int32 code = 1;
+     */
+    code: number;
+    /**
+     * @generated from protobuf field: string message = 2;
+     */
+    message: string;
+}
+declare class WebsocketEvent$Type extends MessageType<WebsocketEvent> {
+    constructor();
+    create(value?: PartialMessage<WebsocketEvent>): WebsocketEvent;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WebsocketEvent): WebsocketEvent;
+    private binaryReadMap1;
+    internalBinaryWrite(message: WebsocketEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.WebsocketEvent
+ */
+export declare const WebsocketEvent: WebsocketEvent$Type;
+declare class WebsocketClientEvent$Type extends MessageType<WebsocketClientEvent> {
+    constructor();
+    create(value?: PartialMessage<WebsocketClientEvent>): WebsocketClientEvent;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WebsocketClientEvent): WebsocketClientEvent;
+    internalBinaryWrite(message: WebsocketClientEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.WebsocketClientEvent
+ */
+export declare const WebsocketClientEvent: WebsocketClientEvent$Type;
+declare class WebsocketAuthRequest$Type extends MessageType<WebsocketAuthRequest> {
+    constructor();
+    create(value?: PartialMessage<WebsocketAuthRequest>): WebsocketAuthRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WebsocketAuthRequest): WebsocketAuthRequest;
+    internalBinaryWrite(message: WebsocketAuthRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.WebsocketAuthRequest
+ */
+export declare const WebsocketAuthRequest: WebsocketAuthRequest$Type;
+declare class WebsocketHealthcheck$Type extends MessageType<WebsocketHealthcheck> {
+    constructor();
+    create(value?: PartialMessage<WebsocketHealthcheck>): WebsocketHealthcheck;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WebsocketHealthcheck): WebsocketHealthcheck;
+    internalBinaryWrite(message: WebsocketHealthcheck, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.WebsocketHealthcheck
+ */
+export declare const WebsocketHealthcheck: WebsocketHealthcheck$Type;
+declare class WebsocketError$Type extends MessageType<WebsocketError> {
+    constructor();
+    create(value?: PartialMessage<WebsocketError>): WebsocketError;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WebsocketError): WebsocketError;
+    internalBinaryWrite(message: WebsocketError, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.client_v1_rpc.WebsocketError
+ */
+export declare const WebsocketError: WebsocketError$Type;
+export {};

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

@@ -0,0 +1,183 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } 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;
+}
+declare class Credentials$Type extends MessageType<Credentials> {
+    constructor();
+    create(value?: PartialMessage<Credentials>): Credentials;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Credentials): Credentials;
+    internalBinaryWrite(message: Credentials, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Credentials
+ */
+export declare const Credentials: Credentials$Type;
+declare class LatencyMeasurements$Type extends MessageType<LatencyMeasurements> {
+    constructor();
+    create(value?: PartialMessage<LatencyMeasurements>): LatencyMeasurements;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LatencyMeasurements): LatencyMeasurements;
+    private binaryReadMap1;
+    internalBinaryWrite(message: LatencyMeasurements, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.LatencyMeasurements
+ */
+export declare const LatencyMeasurements: LatencyMeasurements$Type;
+declare class Latency$Type extends MessageType<Latency> {
+    constructor();
+    create(value?: PartialMessage<Latency>): Latency;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Latency): Latency;
+    internalBinaryWrite(message: Latency, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Latency
+ */
+export declare const Latency: Latency$Type;
+declare class Coordinates$Type extends MessageType<Coordinates> {
+    constructor();
+    create(value?: PartialMessage<Coordinates>): Coordinates;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Coordinates): Coordinates;
+    internalBinaryWrite(message: Coordinates, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Coordinates
+ */
+export declare const Coordinates: Coordinates$Type;
+declare class Edge$Type extends MessageType<Edge> {
+    constructor();
+    create(value?: PartialMessage<Edge>): Edge;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Edge): Edge;
+    internalBinaryWrite(message: Edge, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.Edge
+ */
+export declare const Edge: Edge$Type;
+declare class ICEServer$Type extends MessageType<ICEServer> {
+    constructor();
+    create(value?: PartialMessage<ICEServer>): ICEServer;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICEServer): ICEServer;
+    internalBinaryWrite(message: ICEServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.ICEServer
+ */
+export declare const ICEServer: ICEServer$Type;
+declare class EdgeServer$Type extends MessageType<EdgeServer> {
+    constructor();
+    create(value?: PartialMessage<EdgeServer>): EdgeServer;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EdgeServer): EdgeServer;
+    internalBinaryWrite(message: EdgeServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.coordinator.edge_v1.EdgeServer
+ */
+export declare const EdgeServer: EdgeServer$Type;
+export {};