@dronedeploy/rocos-js-sdk 1.0.0-alpha-2 → 2.6.1

package/utils/transformationmatrix.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformationMatrix = void 0;
+const positionvector_1 = require("./positionvector");
+const rotationmatrix_1 = require("./rotationmatrix");
+const helperfunctions_1 = require("./helperfunctions");
+// TransformationMatrix is 4x4 transformation matrix
+class TransformationMatrix {
+    constructor(elements) {
+        this.elements = elements;
+    }
+    // getRotation returns the local transform's rotation matrix
+    getRotation() {
+        var e = this.elements;
+        return new rotationmatrix_1.RotationMatrix([[e[0][0], e[0][1], e[0][2]],
+            [e[1][0], e[1][1], e[1][2]],
+            [e[2][0], e[2][1], e[2][2]]]);
+    }
+    // getPosition returns the local transform's position vector
+    getPosition() {
+        var e = this.elements;
+        return new positionvector_1.PositionVector([[e[0][3]], [e[1][3]], [e[2][3]]]);
+    }
+    // Multiply multipies with a given matrix
+    Multiply(mB) {
+        var matrixA = this.elements;
+        if (mB instanceof positionvector_1.PositionVector) {
+            var e = mB.elements;
+            var matrixB = [[e[0][0]], [e[1][0]], [e[2][0]], [1]];
+        }
+        else if (mB instanceof rotationmatrix_1.RotationMatrix) {
+            var ele = mB.elements;
+            var matrixB = [
+                [ele[0][0], ele[0][1], ele[0][2]],
+                [ele[1][0], ele[1][1], ele[1][2]],
+                [ele[2][0], ele[2][1], ele[2][2]],
+                [0, 0, 1]
+            ];
+        }
+        else if (mB instanceof TransformationMatrix) {
+            var matrixB = mB.elements;
+        }
+        else {
+            throw "Error occurred";
+        }
+        var aNumRows = matrixA.length, aNumCols = matrixA[0].length, bNumCols = matrixB[0].length, m = new Array(aNumRows);
+        for (var r = 0; r < aNumRows; ++r) {
+            m[r] = new Array(bNumCols);
+            for (var c = 0; c < bNumCols; ++c) {
+                m[r][c] = 0;
+                for (var i = 0; i < aNumCols; ++i) {
+                    m[r][c] += matrixA[r][i] * matrixB[i][c];
+                }
+            }
+        }
+        var rows = m.length;
+        var cols = m[0].length;
+        if (rows == 4 && cols == 4) {
+            return new TransformationMatrix(m);
+        }
+        else if (rows == 4 && cols == 3) {
+            var result = [
+                [m[0][0], m[0][1], m[0][2]],
+                [m[1][0], m[1][1], m[1][2]],
+                [m[2][0], m[2][1], m[2][2]]
+            ];
+            return new rotationmatrix_1.RotationMatrix(result);
+        }
+        else if (rows == 4 && cols == 1) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else {
+            throw "Error occurred";
+        }
+    }
+    // ToFrame returns the transformation matrix relative to the new specified frame
+    ToFrame(tree, originalFrameID, resultFrameID) {
+        if (originalFrameID == resultFrameID) {
+            return this;
+        }
+        else if (tree.isDescendant(originalFrameID, resultFrameID)) {
+            var trans = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(originalFrameID, resultFrameID), false);
+            var totalTM = trans.Multiply(this);
+            if (totalTM instanceof TransformationMatrix) {
+                return totalTM;
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+        else if (tree.isAncestor(originalFrameID, resultFrameID)) {
+            var trans = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(resultFrameID, originalFrameID), true);
+            var totalTM = trans.Multiply(this);
+            if (totalTM instanceof TransformationMatrix) {
+                return totalTM;
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+        else { // Frames are on different branches
+            var commonNode = tree.getCommonFrameID(originalFrameID, resultFrameID);
+            // Calculate the transformation matrix of each frame relative to the common node
+            var totalTM1 = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(originalFrameID, commonNode), false); // calculate down tree matrix
+            var totalTM2 = helperfunctions_1.frameToFrameTransformationMatrixSeq(tree, tree.getSeqDown(resultFrameID, commonNode), true); // calculate up the tree (inverses)
+            var totalTM = totalTM2.Multiply(totalTM1);
+            if (totalTM instanceof TransformationMatrix) {
+                // Apply the transformation
+                var total = totalTM.Multiply(this);
+                if (total instanceof TransformationMatrix) {
+                    return total;
+                }
+                else {
+                    throw "Erorr occurred";
+                }
+            }
+            else {
+                throw "Error occurred";
+            }
+        }
+    }
+}
+exports.TransformationMatrix = TransformationMatrix;

package/utils/vector3.d.ts

@@ -0,0 +1,11 @@
+import { PositionVector } from './positionvector';
+export declare class Vector3 {
+    elements: number[][];
+    constructor(elements: number[][]);
+    X(): number;
+    Y(): number;
+    Z(): number;
+    magnitude(): number;
+    unitVector(): Vector3;
+    Multiply(mB: Vector3 | PositionVector): Vector3 | PositionVector;
+}

package/utils/vector3.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+const positionvector_1 = require("./positionvector");
+// Vector3 is a 3X1 matrix that contains a vector
+class Vector3 {
+    constructor(elements) {
+        this.elements = elements;
+    }
+    X() { return this.elements[0][0]; }
+    Y() { return this.elements[1][0]; }
+    Z() { return this.elements[2][0]; }
+    // magnitude returns the magnitude of the vector
+    magnitude() {
+        var vec = this.elements;
+        var sum = 0;
+        for (var i = 0; i < vec.length; i++) {
+            sum += vec[i][0] ** 2;
+        }
+        return sum ** 0.5;
+    }
+    // unitVector returns the unit vector of the vector
+    unitVector() {
+        var mag = this.magnitude();
+        var e = this.elements;
+        return new Vector3([[e[0][0] / mag], [e[1][0] / mag], [e[2][0] / mag]]);
+    }
+    // Multiply multipies with a given matrix
+    Multiply(mB) {
+        var matrixA = this.elements;
+        if (mB instanceof positionvector_1.PositionVector) {
+            var e = mB.elements;
+            var matrixB = [[e[0][0]], [e[1][0]], [e[2][0]], [1]];
+        }
+        else {
+            throw "Error occurred";
+        }
+        var aNumRows = matrixA.length, aNumCols = matrixA[0].length, bNumCols = matrixB[0].length, m = new Array(aNumRows);
+        for (var r = 0; r < aNumRows; ++r) {
+            m[r] = new Array(bNumCols);
+            for (var c = 0; c < bNumCols; ++c) {
+                m[r][c] = 0;
+                for (var i = 0; i < aNumCols; ++i) {
+                    m[r][c] += matrixA[r][i] * matrixB[i][c];
+                }
+            }
+        }
+        var rows = m.length;
+        var cols = m[0].length;
+        if (rows == 3 && cols == 1 && mB instanceof positionvector_1.PositionVector) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else if (rows == 3 && cols == 1 && mB instanceof Vector3) {
+            return new positionvector_1.PositionVector([[m[0][0]], [m[1][0]], [m[2][0]]]);
+        }
+        else {
+            throw "Error occurred";
+        }
+    }
+}
+exports.Vector3 = Vector3;

package/constants/auth.d.ts

@@ -1,2 +0,0 @@
-/** The expected issuer of the JWT token used to authenticate with our SDK. */
-export declare const issuer = "https://rocos.auth0.com/";

package/constants/auth.js

@@ -1,2 +0,0 @@
-/** The expected issuer of the JWT token used to authenticate with our SDK. */
-export const issuer = 'https://rocos.auth0.com/';

package/grpc/conker_pb.client.d.ts

@@ -1,78 +0,0 @@
-import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import type { StatusMessage } from "./conker_pb";
-import type { StatusRequest } from "./conker_pb";
-import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
-import type { ControlEnd } from "./conker_pb";
-import type { ClientStreamingCall } from "@protobuf-ts/runtime-rpc";
-import type { ControlAck } from "./conker_pb";
-import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
-import type { ControlMessage } from "./conker_pb";
-import type { ConnectRequest } from "./conker_pb";
-import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
-import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export interface IRobotControlClient {
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input: ConnectRequest, options?: RpcOptions): ServerStreamingCall<ConnectRequest, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(options?: RpcOptions): DuplexStreamingCall<ControlAck, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(options?: RpcOptions): ClientStreamingCall<ControlMessage, ControlEnd>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input: ControlMessage, options?: RpcOptions): UnaryCall<ControlMessage, ControlAck>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input: ControlMessage, options?: RpcOptions): ServerStreamingCall<ControlMessage, ControlAck>;
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input: StatusRequest, options?: RpcOptions): UnaryCall<StatusRequest, StatusMessage>;
-}
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export declare class RobotControlClient implements IRobotControlClient, ServiceInfo {
-    private readonly _transport;
-    typeName: string;
-    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
-    options: {
-        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
-    };
-    constructor(_transport: RpcTransport);
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input: ConnectRequest, options?: RpcOptions): ServerStreamingCall<ConnectRequest, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(options?: RpcOptions): DuplexStreamingCall<ControlAck, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(options?: RpcOptions): ClientStreamingCall<ControlMessage, ControlEnd>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input: ControlMessage, options?: RpcOptions): UnaryCall<ControlMessage, ControlAck>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input: ControlMessage, options?: RpcOptions): ServerStreamingCall<ControlMessage, ControlAck>;
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input: StatusRequest, options?: RpcOptions): UnaryCall<StatusRequest, StatusMessage>;
-}

package/grpc/conker_pb.client.js

@@ -1,55 +0,0 @@
-import { RobotControl } from "./conker_pb";
-import { stackIntercept } from "@protobuf-ts/runtime-rpc";
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export class RobotControlClient {
-    constructor(_transport) {
-        this._transport = _transport;
-        this.typeName = RobotControl.typeName;
-        this.methods = RobotControl.methods;
-        this.options = RobotControl.options;
-    }
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input, options) {
-        const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept("serverStreaming", this._transport, method, opt, input);
-    }
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(options) {
-        const method = this.methods[1], opt = this._transport.mergeOptions(options);
-        return stackIntercept("duplex", this._transport, method, opt);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(options) {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
-        return stackIntercept("clientStreaming", this._transport, method, opt);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input, options) {
-        const method = this.methods[3], opt = this._transport.mergeOptions(options);
-        return stackIntercept("unary", this._transport, method, opt, input);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input, options) {
-        const method = this.methods[4], opt = this._transport.mergeOptions(options);
-        return stackIntercept("serverStreaming", this._transport, method, opt, input);
-    }
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input, options) {
-        const method = this.methods[5], opt = this._transport.mergeOptions(options);
-        return stackIntercept("unary", this._transport, method, opt, input);
-    }
-}

package/grpc/conker_pb.d.ts

@@ -1,141 +0,0 @@
-import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import { MessageType } from "@protobuf-ts/runtime";
-/**
- * @generated from protobuf message conker.v1.ConnectRequest
- */
-export interface ConnectRequest {
-}
-/**
- * @generated from protobuf message conker.v1.ControlMessage
- */
-export interface ControlMessage {
-    /**
-     * @generated from protobuf field: string destination = 1;
-     */
-    destination: string;
-    /**
-     * @generated from protobuf field: bytes payload = 2;
-     */
-    payload: Uint8Array;
-    /**
-     * @generated from protobuf field: string txid = 3;
-     */
-    txid: string;
-    /**
-     * @generated from protobuf field: map<string, string> meta = 4;
-     */
-    meta: {
-        [key: string]: string;
-    };
-}
-/**
- * @generated from protobuf message conker.v1.ControlEnd
- */
-export interface ControlEnd {
-    /**
-     * @generated from protobuf field: int32 code = 1;
-     */
-    code: number;
-    /**
-     * @generated from protobuf field: string reason = 2;
-     */
-    reason: string;
-}
-/**
- * @generated from protobuf message conker.v1.ControlAck
- */
-export interface ControlAck {
-    /**
-     * @generated from protobuf field: bool success = 1;
-     */
-    success: boolean;
-    /**
-     * @generated from protobuf field: string stage = 2;
-     */
-    stage: string;
-    /**
-     * @generated from protobuf field: string message = 3;
-     */
-    message: string;
-    /**
-     * @generated from protobuf field: string txid = 4;
-     */
-    txid: string;
-    /**
-     * @generated from protobuf field: int32 seq = 5;
-     */
-    seq: number;
-}
-/**
- * @generated from protobuf message conker.v1.ConnectAck
- */
-export interface ConnectAck {
-}
-/**
- * @generated from protobuf message conker.v1.StatusRequest
- */
-export interface StatusRequest {
-}
-/**
- * @generated from protobuf message conker.v1.StatusMessage
- */
-export interface StatusMessage {
-    /**
-     * @generated from protobuf field: repeated string ConnectedRobots = 1 [json_name = "ConnectedRobots"];
-     */
-    connectedRobots: string[];
-}
-declare class ConnectRequest$Type extends MessageType<ConnectRequest> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.ConnectRequest
- */
-export declare const ConnectRequest: ConnectRequest$Type;
-declare class ControlMessage$Type extends MessageType<ControlMessage> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.ControlMessage
- */
-export declare const ControlMessage: ControlMessage$Type;
-declare class ControlEnd$Type extends MessageType<ControlEnd> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.ControlEnd
- */
-export declare const ControlEnd: ControlEnd$Type;
-declare class ControlAck$Type extends MessageType<ControlAck> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.ControlAck
- */
-export declare const ControlAck: ControlAck$Type;
-declare class ConnectAck$Type extends MessageType<ConnectAck> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.ConnectAck
- */
-export declare const ConnectAck: ConnectAck$Type;
-declare class StatusRequest$Type extends MessageType<StatusRequest> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.StatusRequest
- */
-export declare const StatusRequest: StatusRequest$Type;
-declare class StatusMessage$Type extends MessageType<StatusMessage> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message conker.v1.StatusMessage
- */
-export declare const StatusMessage: StatusMessage$Type;
-/**
- * @generated ServiceType for protobuf service conker.v1.RobotControl
- */
-export declare const RobotControl: ServiceType;
-export {};

package/grpc/conker_pb.grpc-client.d.ts

@@ -1,81 +0,0 @@
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { StatusMessage } from "./conker_pb";
-import type { StatusRequest } from "./conker_pb";
-import type { ControlEnd } from "./conker_pb";
-import type { ControlAck } from "./conker_pb";
-import type { ControlMessage } from "./conker_pb";
-import type { ConnectRequest } from "./conker_pb";
-import * as grpc from "@grpc/grpc-js";
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export interface IRobotControlClient {
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input: ConnectRequest, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlMessage>;
-    connectRobot(input: ConnectRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<ControlAck, ControlMessage>;
-    connectRobotWithAckStream(options?: grpc.CallOptions): grpc.ClientDuplexStream<ControlAck, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ControlEnd) => void): grpc.ClientWritableStream<ControlMessage>;
-    controlRobot(metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ControlEnd) => void): grpc.ClientWritableStream<ControlMessage>;
-    controlRobot(options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ControlEnd) => void): grpc.ClientWritableStream<ControlMessage>;
-    controlRobot(callback: (err: grpc.ServiceError | null, value?: ControlEnd) => void): grpc.ClientWritableStream<ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input: ControlMessage, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ControlAck) => void): grpc.ClientUnaryCall;
-    controlRobotCall(input: ControlMessage, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ControlAck) => void): grpc.ClientUnaryCall;
-    controlRobotCall(input: ControlMessage, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ControlAck) => void): grpc.ClientUnaryCall;
-    controlRobotCall(input: ControlMessage, callback: (err: grpc.ServiceError | null, value?: ControlAck) => void): grpc.ClientUnaryCall;
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input: ControlMessage, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlAck>;
-    controlRobotCallWithAckStream(input: ControlMessage, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlAck>;
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input: StatusRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: StatusMessage) => void): grpc.ClientUnaryCall;
-    status(input: StatusRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: StatusMessage) => void): grpc.ClientUnaryCall;
-    status(input: StatusRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: StatusMessage) => void): grpc.ClientUnaryCall;
-    status(input: StatusRequest, callback: (err: grpc.ServiceError | null, value?: StatusMessage) => void): grpc.ClientUnaryCall;
-}
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export declare class RobotControlClient extends grpc.Client implements IRobotControlClient {
-    private readonly _binaryOptions;
-    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input: ConnectRequest, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<ControlAck, ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ControlEnd) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ControlEnd) => void), callback?: ((err: grpc.ServiceError | null, value?: ControlEnd) => void)): grpc.ClientWritableStream<ControlMessage>;
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input: ControlMessage, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ControlAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ControlAck) => void), callback?: ((err: grpc.ServiceError | null, value?: ControlAck) => void)): grpc.ClientUnaryCall;
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input: ControlMessage, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ControlAck>;
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input: StatusRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: StatusMessage) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: StatusMessage) => void), callback?: ((err: grpc.ServiceError | null, value?: StatusMessage) => void)): grpc.ClientUnaryCall;
-}

package/grpc/conker_pb.grpc-client.js

@@ -1,58 +0,0 @@
-/* eslint-disable */
-// @generated by protobuf-ts 2.9.1 with parameter ts_nocheck,eslint_disable,add_pb_suffix,client_grpc1,optimize_code_size
-// @generated from protobuf file "conker.proto" (package "conker.v1", syntax proto3)
-// tslint:disable
-// @ts-nocheck
-import { RobotControl } from "./conker_pb";
-import * as grpc from "@grpc/grpc-js";
-/**
- * @generated from protobuf service conker.v1.RobotControl
- */
-export class RobotControlClient extends grpc.Client {
-    constructor(address, credentials, options = {}, binaryOptions = {}) {
-        super(address, credentials, options);
-        this._binaryOptions = binaryOptions;
-    }
-    /**
-     * @generated from protobuf rpc: ConnectRobot(conker.v1.ConnectRequest) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobot(input, metadata, options) {
-        const method = RobotControl.methods[0];
-        return this.makeServerStreamRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
-    }
-    /**
-     * @generated from protobuf rpc: ConnectRobotWithAckStream(stream conker.v1.ControlAck) returns (stream conker.v1.ControlMessage);
-     */
-    connectRobotWithAckStream(metadata, options) {
-        const method = RobotControl.methods[1];
-        return this.makeBidiStreamRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), metadata, options);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobot(stream conker.v1.ControlMessage) returns (conker.v1.ControlEnd);
-     */
-    controlRobot(metadata, options, callback) {
-        const method = RobotControl.methods[2];
-        return this.makeClientStreamRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), metadata, options, callback);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobotCall(conker.v1.ControlMessage) returns (conker.v1.ControlAck);
-     */
-    controlRobotCall(input, metadata, options, callback) {
-        const method = RobotControl.methods[3];
-        return this.makeUnaryRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
-    }
-    /**
-     * @generated from protobuf rpc: ControlRobotCallWithAckStream(conker.v1.ControlMessage) returns (stream conker.v1.ControlAck);
-     */
-    controlRobotCallWithAckStream(input, metadata, options) {
-        const method = RobotControl.methods[4];
-        return this.makeServerStreamRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
-    }
-    /**
-     * @generated from protobuf rpc: Status(conker.v1.StatusRequest) returns (conker.v1.StatusMessage);
-     */
-    status(input, metadata, options, callback) {
-        const method = RobotControl.methods[5];
-        return this.makeUnaryRequest(`/${RobotControl.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
-    }
-}