@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.19

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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,58 @@
+/* eslint-disable */
+// @generated by protobuf-ts 2.9.1 with parameter ts_nocheck,eslint_disable,add_pb_suffix,client_grpc1,optimize_code_size,long_type_string
+// @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);
+    }
+}

package/grpc/conker_pb.js

@@ -0,0 +1,104 @@
+/* eslint-disable */
+// @generated by protobuf-ts 2.9.1 with parameter ts_nocheck,eslint_disable,add_pb_suffix,client_grpc1,optimize_code_size,long_type_string
+// @generated from protobuf file "conker.proto" (package "conker.v1", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { MessageType } from "@protobuf-ts/runtime";
+// @generated message type with reflection information, may provide speed optimized methods
+class ConnectRequest$Type extends MessageType {
+    constructor() {
+        super("conker.v1.ConnectRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.ConnectRequest
+ */
+export const ConnectRequest = new ConnectRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ControlMessage$Type extends MessageType {
+    constructor() {
+        super("conker.v1.ControlMessage", [
+            { no: 1, name: "destination", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "payload", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "txid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "meta", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.ControlMessage
+ */
+export const ControlMessage = new ControlMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ControlEnd$Type extends MessageType {
+    constructor() {
+        super("conker.v1.ControlEnd", [
+            { no: 1, name: "code", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.ControlEnd
+ */
+export const ControlEnd = new ControlEnd$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ControlAck$Type extends MessageType {
+    constructor() {
+        super("conker.v1.ControlAck", [
+            { no: 1, name: "success", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "stage", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "txid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "seq", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.ControlAck
+ */
+export const ControlAck = new ControlAck$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ConnectAck$Type extends MessageType {
+    constructor() {
+        super("conker.v1.ConnectAck", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.ConnectAck
+ */
+export const ConnectAck = new ConnectAck$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StatusRequest$Type extends MessageType {
+    constructor() {
+        super("conker.v1.StatusRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.StatusRequest
+ */
+export const StatusRequest = new StatusRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StatusMessage$Type extends MessageType {
+    constructor() {
+        super("conker.v1.StatusMessage", [
+            { no: 1, name: "ConnectedRobots", kind: "scalar", jsonName: "ConnectedRobots", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message conker.v1.StatusMessage
+ */
+export const StatusMessage = new StatusMessage$Type();
+/**
+ * @generated ServiceType for protobuf service conker.v1.RobotControl
+ */
+export const RobotControl = new ServiceType("conker.v1.RobotControl", [
+    { name: "ConnectRobot", serverStreaming: true, options: {}, I: ConnectRequest, O: ControlMessage },
+    { name: "ConnectRobotWithAckStream", serverStreaming: true, clientStreaming: true, options: {}, I: ControlAck, O: ControlMessage },
+    { name: "ControlRobot", clientStreaming: true, options: {}, I: ControlMessage, O: ControlEnd },
+    { name: "ControlRobotCall", options: {}, I: ControlMessage, O: ControlAck },
+    { name: "ControlRobotCallWithAckStream", serverStreaming: true, options: {}, I: ControlMessage, O: ControlAck },
+    { name: "Status", options: {}, I: StatusRequest, O: StatusMessage }
+]);

package/grpc/filagree_pb.client.d.ts

@@ -0,0 +1,68 @@
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import type { OpResults } from "./filagree_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RxStatus } from "./filagree_pb";
+import type { ChunkData } from "./filagree_pb";
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { OpRequests } from "./filagree_pb";
+import type { Zip } from "./filagree_pb";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service filagree.v1.Filagree
+ */
+export interface IFilagreeClient {
+    /**
+     * @generated from protobuf rpc: AgentGetOps(filagree.v1.Zip) returns (stream filagree.v1.OpRequests);
+     */
+    agentGetOps(input: Zip, options?: RpcOptions): ServerStreamingCall<Zip, OpRequests>;
+    /**
+     * @generated from protobuf rpc: AgentUpload(stream filagree.v1.ChunkData) returns (stream filagree.v1.RxStatus);
+     */
+    agentUpload(options?: RpcOptions): DuplexStreamingCall<ChunkData, RxStatus>;
+    /**
+     * @generated from protobuf rpc: AgentDownload(stream filagree.v1.RxStatus) returns (stream filagree.v1.ChunkData);
+     */
+    agentDownload(options?: RpcOptions): DuplexStreamingCall<RxStatus, ChunkData>;
+    /**
+     * @generated from protobuf rpc: SendInfo(filagree.v1.OpResults) returns (filagree.v1.Zip);
+     */
+    sendInfo(input: OpResults, options?: RpcOptions): UnaryCall<OpResults, Zip>;
+    /**
+     * @generated from protobuf rpc: ServerReqOp(filagree.v1.OpRequests) returns (filagree.v1.OpResults);
+     */
+    serverReqOp(input: OpRequests, options?: RpcOptions): UnaryCall<OpRequests, OpResults>;
+}
+/**
+ * @generated from protobuf service filagree.v1.Filagree
+ */
+export declare class FilagreeClient implements IFilagreeClient, 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: AgentGetOps(filagree.v1.Zip) returns (stream filagree.v1.OpRequests);
+     */
+    agentGetOps(input: Zip, options?: RpcOptions): ServerStreamingCall<Zip, OpRequests>;
+    /**
+     * @generated from protobuf rpc: AgentUpload(stream filagree.v1.ChunkData) returns (stream filagree.v1.RxStatus);
+     */
+    agentUpload(options?: RpcOptions): DuplexStreamingCall<ChunkData, RxStatus>;
+    /**
+     * @generated from protobuf rpc: AgentDownload(stream filagree.v1.RxStatus) returns (stream filagree.v1.ChunkData);
+     */
+    agentDownload(options?: RpcOptions): DuplexStreamingCall<RxStatus, ChunkData>;
+    /**
+     * @generated from protobuf rpc: SendInfo(filagree.v1.OpResults) returns (filagree.v1.Zip);
+     */
+    sendInfo(input: OpResults, options?: RpcOptions): UnaryCall<OpResults, Zip>;
+    /**
+     * @generated from protobuf rpc: ServerReqOp(filagree.v1.OpRequests) returns (filagree.v1.OpResults);
+     */
+    serverReqOp(input: OpRequests, options?: RpcOptions): UnaryCall<OpRequests, OpResults>;
+}

package/grpc/filagree_pb.client.js

@@ -0,0 +1,48 @@
+import { Filagree } from "./filagree_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service filagree.v1.Filagree
+ */
+export class FilagreeClient {
+    constructor(_transport) {
+        this._transport = _transport;
+        this.typeName = Filagree.typeName;
+        this.methods = Filagree.methods;
+        this.options = Filagree.options;
+    }
+    /**
+     * @generated from protobuf rpc: AgentGetOps(filagree.v1.Zip) returns (stream filagree.v1.OpRequests);
+     */
+    agentGetOps(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: AgentUpload(stream filagree.v1.ChunkData) returns (stream filagree.v1.RxStatus);
+     */
+    agentUpload(options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("duplex", this._transport, method, opt);
+    }
+    /**
+     * @generated from protobuf rpc: AgentDownload(stream filagree.v1.RxStatus) returns (stream filagree.v1.ChunkData);
+     */
+    agentDownload(options) {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept("duplex", this._transport, method, opt);
+    }
+    /**
+     * @generated from protobuf rpc: SendInfo(filagree.v1.OpResults) returns (filagree.v1.Zip);
+     */
+    sendInfo(input, options) {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: ServerReqOp(filagree.v1.OpRequests) returns (filagree.v1.OpResults);
+     */
+    serverReqOp(input, options) {
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}