@dronedeploy/rocos-js-sdk 3.0.1-alpha → 3.0.1-alpha.11

package/esm/api/streams/caller/CallerStreamAbstract.d.ts

@@ -0,0 +1,23 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { RequestCancellation } from '../../../grpc/serviette.v1_pb';
+import { Logger } from 'loglevel';
+export declare abstract class CallerStreamAbstract implements ICallerStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected abstract callService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected abstract getPayload(payload: string): Uint8Array;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
+    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
+    private createCancellationRequest;
+    private createServiceRequest;
+}

package/esm/api/streams/caller/CallerStreamNode.d.ts

@@ -0,0 +1,13 @@
+import { ICallerParams, IRocosCallerMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+export declare class CallerStreamNode extends CallerStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected callService(request: ServiceRequest, params: ICallerParams): Observable<IRocosCallerMessage>;
+    private callStream;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/esm/api/streams/command/CommandStream.d.ts

@@ -0,0 +1,10 @@
+import { ICommandParams, IRocosCommandMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+export declare class CommandStream extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}

package/esm/api/streams/command/CommandStream.js

@@ -0,0 +1,67 @@
+import { RocosCommandMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandClient } from '../../../grpc/rambo.v1_pb.client';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class CommandStream extends CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`CommandStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new CommandClient(transport);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const abortController = new AbortController();
+        return new Observable((emitter) => {
+            const call = this.client.callCommand(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const message = RocosCommandMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug('invokeRequest - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('invokeRequest - on(error)', {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.error(error);
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.complete();
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                abortController.abort();
+            };
+        });
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}

package/esm/api/streams/command/CommandStreamAbstract.d.ts

@@ -0,0 +1,20 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ICommandParams, ICommandStream, IRocosCommandMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { Logger } from 'loglevel';
+export declare abstract class CommandStreamAbstract implements ICommandStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICommandParams): Observable<IRocosCommandMessage>;
+    private createCommandRequest;
+    private createRocosUriPath;
+}

package/esm/api/streams/command/CommandStreamNode.d.ts

@@ -0,0 +1,10 @@
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { ICommandParams, IRocosCommandMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+export declare class CommandStreamNode extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}

package/esm/api/streams/control/ControlStream.d.ts

@@ -0,0 +1,12 @@
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { IControlParams, IRocosControlMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+export declare class ControlStream extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): Promise<void>;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/esm/api/streams/control/ControlStream.js

@@ -0,0 +1,76 @@
+import { RocosControlMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RobotControlClient } from '../../../grpc/conker_pb.client';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { stringToUint8Array } from '../../../helpers/stringToUint8Array';
+export class ControlStream extends ControlStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`ControlStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new RobotControlClient(transport);
+    }
+    async controlRobotCall(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        await this.client.controlRobotCall(request, { meta: metadata });
+    }
+    controlRobotCallWithAckStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const abortController = new AbortController();
+        return new Observable((emitter) => {
+            // Send the message to back-end.
+            const call = this.client.controlRobotCallWithAckStream(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const message = RocosControlMessage.fromMessage(update);
+                emitter.next(message);
+                this.logger.debug('controlRobotCallWithAckStream - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.complete();
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('controlRobotCallWithAckStream- on(error)', {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing controlRobotCallWithAckStream');
+                abortController.abort();
+            };
+        });
+    }
+    getPayload(payload) {
+        return stringToUint8Array(payload);
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}

package/esm/api/streams/control/ControlStreamAbstract.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ControlActionType, IControlParams, IControlStream, IRocosControlMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { Logger } from 'loglevel';
+export declare abstract class ControlStreamAbstract implements IControlStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected abstract controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected abstract getPayload(payload: string): Uint8Array | undefined;
+    setToken(token: string): void;
+    stopStream(): void;
+    takeActionWithAck(action: ControlActionType, params: IControlParams, ackTimeoutInSeconds?: number): Observable<string>;
+    private rosbridgeControl;
+    sendCommand(params: IControlParams): void;
+    sendCommandWithAck(params: IControlParams): Observable<IRocosControlMessage>;
+    private sendCommandToRobot;
+    private setRequestMeta;
+}

package/esm/api/streams/control/ControlStreamNode.d.ts

@@ -0,0 +1,12 @@
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { IControlParams, IRocosControlMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+export declare class ControlStreamNode extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/esm/api/streams/fileAccessor/FileAccessorStream.d.ts

@@ -0,0 +1,8 @@
+import { IFileAccessorReqOpParams, IRocosOpResultMessage, IStreamConfig } from '../../../models';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+export declare class FileAccessorStream extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}

package/esm/api/streams/fileAccessor/FileAccessorStream.js

@@ -0,0 +1,60 @@
+import { OpRequestTarget, RocosOpResultMessage, SubscriberStatusEnum, } from '../../../models';
+import { FilagreeClient } from '../../../grpc/filagree_pb.client';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { OpRequests } from '../../../grpc/filagree_pb';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class FileAccessorStream extends FileAccessorStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`FileAccessorStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new FilagreeClient(transport);
+    }
+    async serverReqOpInternal(params) {
+        this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+        this.statusStream$.next(this.subscriberStatus);
+        this.logger.debug('serverReqOp - request', {
+            status: this.subscriberStatus,
+            projectId: params.projectId,
+            callsign: params.callsign,
+        });
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const reqs = OpRequests.create({
+            requests: [
+                {
+                    opcode: params.opCode.valueOf(),
+                    path: params.path,
+                    target: params.target?.valueOf() ?? OpRequestTarget.AGENT,
+                    args: params.args,
+                },
+            ],
+        });
+        const response = await this.client.serverReqOp(reqs, { meta: metadata }).response;
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.statusStream$.next(this.subscriberStatus);
+        this.logger.debug('serverReqOp - response', {
+            status: this.subscriberStatus,
+            projectId: params.projectId,
+            callsign: params.callsign,
+        });
+        if (response) {
+            return RocosOpResultMessage.fromMessages(response);
+        }
+        throw new Error('Error in serverReqOp call');
+    }
+    getMetadata(projectId, callsign) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        if (callsign) {
+            result['r-cs'] = callsign;
+        }
+        return result;
+    }
+}

package/esm/api/streams/fileAccessor/FileAccessorStreamAbstract.d.ts

@@ -0,0 +1,21 @@
+import { IFileAccessorParams, IFileAccessorReqOpParams, IFileAccessorStream, IRocosOpResultMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { BehaviorSubject } from 'rxjs';
+import { Logger } from 'loglevel';
+export declare abstract class FileAccessorStreamAbstract implements IFileAccessorStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    setToken(token: string): void;
+    stopStream(): void;
+    serverReqOp(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    listFolder(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    downloadFile(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    getDownloadFileLinkByUsingBlob(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    private getPathForBlobSas;
+}

package/esm/api/streams/fileAccessor/FileAccessorStreamNode.d.ts

@@ -0,0 +1,8 @@
+import { IFileAccessorReqOpParams, IRocosOpResultMessage, IStreamConfig } from '../../../models';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+export declare class FileAccessorStreamNode extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}

package/esm/api/streams/search/SearchStream.d.ts

@@ -0,0 +1,13 @@
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane_pb';
+import { IRocosSearchMessage, IRocosSearchStatusMessage, ISearchParams, ISearchQueryParams, ISearchStreamParams, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { SearchStreamAbstract } from './SearchStreamAbstract';
+export declare class SearchStream extends SearchStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private getMetadata;
+}

package/esm/api/streams/search/SearchStream.js

@@ -0,0 +1,97 @@
+import { DeleteProjectMessage, Empty } from '../../../grpc/slowlane_pb';
+import { RocosSearchMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { SearchStreamAbstract } from './SearchStreamAbstract';
+import { streamClient } from '../../../grpc/slowlane_pb.client';
+export class SearchStream extends SearchStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`SearchStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new streamClient(transport);
+    }
+    searchStreamInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        const abortController = new AbortController();
+        return new Observable((emitter) => {
+            const call = this.client.searchStream(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const dataSetList = update.dataset;
+                const results = dataSetList.map((item) => {
+                    return RocosSearchMessage.fromMessage(item);
+                });
+                emitter.next(results);
+                this.logger.debug('searchStream - on(data)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(end)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+                emitter.complete();
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('searchStream - on(error)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                    error,
+                });
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing searchStream');
+                abortController.abort();
+            };
+        });
+    }
+    async queryDataInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        const response = await this.client.queryData(request, { meta: metadata }).response;
+        if (!response) {
+            throw new Error('Error with search query.');
+        }
+        return response.result;
+    }
+    async healthCheckInternal(params) {
+        const request = Empty.create();
+        const metadata = this.getMetadata(params.projectId);
+        const response = await this.client.healthCheck(request, { meta: metadata }).response;
+        if (!response) {
+            throw new Error('Error with health check.');
+        }
+        return response;
+    }
+    async deleteProjectDataInternal(params) {
+        const request = DeleteProjectMessage.create({
+            projectId: params.projectId,
+        });
+        const metadata = this.getMetadata(params.projectId);
+        const response = await this.client.deleteProjectData(request, { meta: metadata }).response;
+        if (!response) {
+            throw new Error('Error with deleting project data.');
+        }
+        return response;
+    }
+    getMetadata(projectId) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+        };
+    }
+}

package/esm/api/streams/search/SearchStreamAbstract.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane_pb';
+import { IRocosSearchMessage, IRocosSearchStatusMessage, ISearchParams, ISearchQueryParams, ISearchStream, ISearchStreamParams, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { Logger } from 'loglevel';
+export declare abstract class SearchStreamAbstract implements ISearchStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected abstract queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected abstract healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected abstract deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    setToken(token: string): void;
+    stopStream(): void;
+    searchStream(params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    queryData(params: ISearchQueryParams): Promise<string>;
+    healthCheck(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    deleteProjectData(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private convertToQueryMessage;
+}

package/esm/api/streams/search/SearchStreamNode.d.ts

@@ -0,0 +1,13 @@
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane_pb';
+import { IRocosSearchMessage, IRocosSearchStatusMessage, ISearchParams, ISearchQueryParams, ISearchStreamParams, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { SearchStreamAbstract } from './SearchStreamAbstract';
+export declare class SearchStreamNode extends SearchStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private getMetadata;
+}

package/esm/api/streams/telemetry/TelemetryStream.d.ts

@@ -0,0 +1,17 @@
+import { ITelemetryStreamConfig } from '../../../models';
+import { TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby_pb';
+import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
+export declare class TelemetryStream extends TelemetryStreamAbstract {
+    private client;
+    private abortController?;
+    constructor(config: ITelemetryStreamConfig);
+    protected stopInternal(): void;
+    protected registerReceiver(): () => void;
+    private onError;
+    private onEnd;
+    private getMetadata;
+    protected requestTelemetry(req: TelemetryRequest): Promise<void>;
+    protected requestTelemetryQuery(req: TelemetryQueryRequest): Promise<void>;
+    protected sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
+    protected sendHeartbeat(): void;
+}

package/esm/api/streams/telemetry/TelemetryStream.js

@@ -0,0 +1,98 @@
+import { SubscriberStatusEnum } from '../../../models';
+import { RegistrationMessage, } from '../../../grpc/teletubby_pb';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { TelemetryGatewayClient } from '../../../grpc/teletubby_pb.client';
+import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
+export class TelemetryStream extends TelemetryStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new TelemetryGatewayClient(transport);
+    }
+    stopInternal() {
+        if (this.abortController) {
+            this.logger.info('Starting stop stream process');
+            this.abortController.abort();
+            this.abortController = undefined;
+            this.logger.info('Finished stop stream process');
+        }
+    }
+    registerReceiver() {
+        this.logger.info('registerReceiver');
+        // Reset counter
+        this.receivedMessagesCount = 0;
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        const call = this.client.registerReceiver(RegistrationMessage.create(), {
+            meta: this.getMetadata(this.projectId),
+            abort: abortController.signal,
+        });
+        call.responses.onMessage((msg) => {
+            this.onData(msg, false);
+        });
+        call.responses.onError((error) => {
+            void this.onError(error);
+            this.onEnd(false);
+        });
+        call.responses.onComplete(() => {
+            this.onEnd(true);
+        });
+        this.listenMessagesAndRenew();
+        return () => {
+            abortController.abort();
+        };
+    }
+    async onError(e) {
+        this.logger.error(`Telemetry Stream Error: ${e}, SubscriberId: ${this.subscriberId}`);
+        this.subscriberStatus = SubscriberStatusEnum.ERROR;
+        this.statusStream$.next(this.subscriberStatus);
+    }
+    onEnd(ok) {
+        this.logger.debug('registerReceiver', 'end');
+        if (ok) {
+            // ResourceExhausted
+            this.stopInternal();
+            this.registerReceiver();
+        }
+    }
+    getMetadata(projectId) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        return result;
+    }
+    async requestTelemetry(req) {
+        this.logger.debug('Sending telemetry request');
+        try {
+            await this.client.requestTelemetry(req, { meta: this.getMetadata(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetry ', e);
+            throw e;
+        }
+    }
+    async requestTelemetryQuery(req) {
+        this.logger.debug('Requesting telemetry with query');
+        try {
+            await this.client.requestTelemetryQuery(req, { meta: this.getMetadata(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetryQuery ', e);
+            throw e;
+        }
+    }
+    sendAcknowledgmentInternal(uid, status, noRetry) {
+        this.logger.error('Error can not send Acknowledgment on grpc-web client', { uid, status, noRetry });
+        return false;
+    }
+    sendHeartbeat() {
+        // can not send heartbeat on grpc-web
+    }
+}