@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/services/SpotProvisioningService.d.ts

@@ -0,0 +1,14 @@
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Timezone } from '../constants/timezones';
+declare type SpotImageTag = 'stable' | 'dev' | 'unstable';
+export declare class SpotProvisioningService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    getSpotCoreImage(projectId: string, profileId: string, robot: {
+        callsign: string;
+        name: string;
+    }, tag?: SpotImageTag, patMetadata?: Record<string, unknown>, timezone?: Timezone): Promise<Blob>;
+}
+export {};

package/services/SpotProvisioningService.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotProvisioningService = void 0;
+const models_1 = require("../models");
+const api_1 = require("../constants/api");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const RocosStore_1 = require("../store/RocosStore");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class SpotProvisioningService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`SpotService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.SPOT_SERVICE_ERROR);
+    }
+    async getSpotCoreImage(projectId, profileId, robot, tag = 'stable', patMetadata, timezone) {
+        const userService = RocosStore_1.RocosStore.getSDKInstance(this.config).getUserService();
+        const pat = await userService.createPAT({
+            name: `Spot provisioning token for ${robot.callsign}`,
+            projectId,
+            scope: ['provisioning'],
+            robotDefinitionId: profileId,
+            metaData: Object.assign({ singleUse: true, defaultRobotDefinitionId: profileId }, patMetadata),
+            ttlDays: 90,
+        });
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_SPOTTY_URL, { url: this.config.url }, this.config.insecure), {
+            pat: pat.pat,
+            callsign: robot.callsign,
+            robotName: robot.name,
+            project: projectId,
+            agentImageTag: tag,
+            timezone,
+        }, 'Failed to get image.', {
+            responseType: 'blob',
+        });
+    }
+}
+exports.SpotProvisioningService = SpotProvisioningService;

package/services/SpotProvisioningServiceNode.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Timezone } from '../constants/timezones';
+declare type SpotImageTag = 'stable' | 'dev' | 'unstable';
+export declare class SpotProvisioningServiceNode extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    getSpotCoreImage(projectId: string, profileId: string, robot: {
+        callsign: string;
+        name: string;
+    }, tag?: SpotImageTag, patMetadata?: Record<string, unknown>, timezone?: Timezone): Promise<NodeJS.ReadableStream>;
+}
+export {};

package/services/SpotProvisioningServiceNode.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotProvisioningServiceNode = void 0;
+const models_1 = require("../models");
+const api_1 = require("../constants/api");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const RocosStore_1 = require("../store/RocosStore");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class SpotProvisioningServiceNode extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`SpotService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.SPOT_SERVICE_ERROR);
+    }
+    async getSpotCoreImage(projectId, profileId, robot, tag = 'stable', patMetadata, timezone) {
+        const userService = RocosStore_1.RocosStore.getSDKInstance(this.config).getUserService();
+        const pat = await userService.createPAT({
+            name: `Spot provisioning token for ${robot.callsign}`,
+            projectId,
+            scope: ['provisioning'],
+            robotDefinitionId: profileId,
+            metaData: Object.assign({ defaultRobotDefinitionId: profileId, singleUse: true }, patMetadata),
+            ttlDays: 90,
+        });
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_SPOTTY_URL, { url: this.config.url }, this.config.insecure), {
+            pat: pat.pat,
+            callsign: robot.callsign,
+            robotName: robot.name,
+            project: projectId,
+            agentImageTag: tag,
+            timezone,
+        }, 'Failed to get image.', {
+            responseType: 'stream',
+        });
+    }
+}
+exports.SpotProvisioningServiceNode = SpotProvisioningServiceNode;

package/services/StreamService.d.ts

@@ -0,0 +1,98 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { ISource } from '../models/ISource';
+import { IStream } from '../models/IStream';
+import { IStreamSource } from '../models/IStreamSource';
+export declare class StreamService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Create a new stream.
+     *
+     * @param projectId - Project Id
+     * @param stream - Stream object
+     */
+    create(projectId: string, stream: IStream): Promise<any>;
+    /**
+     * Get streams list by project id.
+     */
+    list(projectId: string): Promise<IStream[]>;
+    /**
+     * Get stream information by project id and stream id.
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     */
+    info(projectId: string, streamId: string): Promise<IStream>;
+    /**
+     * Add new data to the stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param sources - Payload {@link IStreamSource[]}
+     */
+    addData(projectId: string, streamId: string, sources: IStreamSource[]): Promise<any>;
+    /**
+     * Get sources for stream.
+     */
+    sources(): Promise<ISource[]>;
+    /**
+     * Get source info
+     *
+     * @param sourceId - Source Id
+     */
+    sourceInfo(sourceId: string): Promise<ISource>;
+    /**
+     * Get streams list of robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot's Callsign
+     */
+    streamsForRobot(projectId: string, callsign: string): Promise<IStream[]>;
+    /**
+     * Bind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should bind with stream
+     */
+    bindRobot(projectId: string, streamId: string, callsigns: string[]): Promise<any>;
+    /**
+     * Unbind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should unbind with stream
+     */
+    unbindRobot(projectId: string, streamId: string, callsigns: string[]): Promise<any>;
+    /**
+     * Remove streams by list
+     *
+     * @param projectId - Project Id
+     * @param streamIds - Stream Ids
+     */
+    removeStreams(projectId: string, streamIds: string[]): Promise<any>;
+    /**
+     * Remove stream data by dataIds list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param dataIds - Data Ids, e.g. {sourceId: string, dataId: string}
+     */
+    removeStreamData(projectId: string, streamId: string, dataIds: any[]): Promise<any>;
+    /**
+     * Remove stream data by ids list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param ids - ids list (string[])
+     */
+    removeStreamDataByIds(projectId: string, streamId: string, ids: string[]): Promise<any>;
+    /**
+     * Get stream data exporter templates list
+     */
+    dataExporterTemplates(): Promise<any>;
+}

package/services/StreamService.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamService = void 0;
+const api_1 = require("../constants/api");
+const RocosError_1 = require("../models/RocosError");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const Stream_1 = require("../models/Stream");
+const StreamSource_1 = require("../models/StreamSource");
+const cleanObject_1 = require("../helpers/cleanObject");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`StreamService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.STREAM_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a new stream.
+     *
+     * @param projectId - Project Id
+     * @param stream - Stream object
+     */
+    // TODO: map the response object
+    async create(projectId, stream) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), cleanObject_1.cleanObject(new Stream_1.Stream(stream)), `Failed to create stream for ${projectId}.`);
+    }
+    /**
+     * Get streams list by project id.
+     */
+    async list(projectId) {
+        const data = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get streams for ${projectId}.`);
+        return data.map((stream) => cleanObject_1.cleanObject(new Stream_1.Stream(stream)));
+    }
+    /**
+     * Get stream information by project id and stream id.
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     */
+    async info(projectId, streamId) {
+        const data = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_ID_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to get stream for ${projectId}, streamId ${streamId}.`);
+        return cleanObject_1.cleanObject(new Stream_1.Stream(data));
+    }
+    /**
+     * Add new data to the stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param sources - Payload {@link IStreamSource[]}
+     */
+    // TODO: map the response object
+    async addData(projectId, streamId, sources) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), { data: sources.map((source) => cleanObject_1.cleanObject(new StreamSource_1.StreamSource(source))) }, `Failed add data to stream for ${projectId}, streamId ${streamId}.`);
+    }
+    /**
+     * Get sources for stream.
+     */
+    async sources() {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SOURCE_URL, { url: this.config.url }, this.config.insecure), 'Failed to get sources for stream.');
+    }
+    /**
+     * Get source info
+     *
+     * @param sourceId - Source Id
+     */
+    async sourceInfo(sourceId) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SOURCE_ID_URL, { url: this.config.url, sourceId }, this.config.insecure), `Failed add et source info for ${sourceId}.`);
+    }
+    /**
+     * Get streams list of robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot's Callsign
+     */
+    async streamsForRobot(projectId, callsign) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_CALLSIGN_STREAM_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed get streams for ${projectId}, callsign ${callsign}.`);
+    }
+    /**
+     * Bind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should bind with stream
+     */
+    // TODO: map the response object
+    async bindRobot(projectId, streamId, callsigns) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), callsigns, `Failed to bind robot with stream for ${projectId}, streamId ${streamId}.`);
+    }
+    /**
+     * Unbind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should unbind with stream
+     */
+    // TODO: map the response object
+    async unbindRobot(projectId, streamId, callsigns) {
+        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to unbind robot with stream for ${projectId}, streamId ${streamId}.`, callsigns);
+    }
+    /**
+     * Remove streams by list
+     *
+     * @param projectId - Project Id
+     * @param streamIds - Stream Ids
+     */
+    // TODO: map the response object
+    async removeStreams(projectId, streamIds) {
+        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to remove stream for ${projectId}.`, streamIds);
+    }
+    /**
+     * Remove stream data by dataIds list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param dataIds - Data Ids, e.g. {sourceId: string, dataId: string}
+     */
+    // TODO: map the response object
+    async removeStreamData(projectId, streamId, dataIds) {
+        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, dataIds);
+    }
+    /**
+     * Remove stream data by ids list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param ids - ids list (string[])
+     */
+    // TODO: map the response object
+    async removeStreamDataByIds(projectId, streamId, ids) {
+        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, ids);
+    }
+    /**
+     * Get stream data exporter templates list
+     */
+    // TODO: map the response object
+    async dataExporterTemplates() {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_TEMPLATE_EXPORTER_URL, { url: this.config.url }, this.config.insecure), 'Failed to get data exporters.');
+    }
+}
+exports.StreamService = StreamService;

package/services/TelemetryService.d.ts

@@ -0,0 +1,43 @@
+import { Observable, Subject } from 'rxjs';
+import { ITelemetrySubscriptionParams, ITelemetrySubscriptions } from '../models/params/ITelemetryParams';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IRocosTelemetryMessage } from '../models/message/IRocosTelemetryMessage';
+import { IStreamStatusMessage } from '../models/message/IStreamStatusMessage';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { ITelemetryStream } from '../models/stream/ITelemetryStream';
+import { ITelemetryStreamConfig } from '../models/ITelemetryStreamConfig';
+import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
+export declare class TelemetryService implements IBaseService, ISubscriberStatus {
+    private config;
+    private logger;
+    private status;
+    private statusSubscription;
+    private changeStream$;
+    private streamStatusSubject$;
+    status$: Subject<SubscriberStatusEnum>;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    /**
+     * The main method for subscribing to telemetry messages
+     *
+     * @param params - Subscription params
+     *
+     * @returns An Observable that outputs telemetry messages
+     */
+    subscribe(params: ITelemetrySubscriptionParams): Observable<IRocosTelemetryMessage>;
+    /**
+     * A method to keep track of the current subscriptions
+     *
+     * @returns An Observable that outputs subscription changes
+     */
+    getSubscriptionChanges(): Observable<ITelemetrySubscriptions>;
+    /**
+     * A method to keep track of the stream status
+     *
+     * @returns An Observable that outputs stream status
+     */
+    getStatusChanges(): Observable<IStreamStatusMessage>;
+    private initStream;
+    protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
+}

package/services/TelemetryService.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryService = void 0;
+const rxjs_1 = require("rxjs");
+const RocosError_1 = require("../models/RocosError");
+const operators_1 = require("rxjs/operators");
+const CallsignsLookup_1 = require("../models/callsigns/CallsignsLookup");
+const CallsignsEnums_1 = require("../models/callsigns/CallsignsEnums");
+const identifier_1 = require("../constants/identifier");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const RocosStore_1 = require("../store/RocosStore");
+const StreamRegister_1 = require("../api/StreamRegister");
+const SubscriberStatusEnum_1 = require("../models/SubscriberStatusEnum");
+const TelemetryStream_1 = require("../api/streams/telemetry/TelemetryStream");
+const arrayUnique_1 = require("../helpers/arrayUnique");
+const getUniqueId_1 = require("../helpers/getUniqueId");
+class TelemetryService {
+    constructor(config) {
+        this.status = false;
+        this.changeStream$ = new rxjs_1.BehaviorSubject(new Map());
+        this.status$ = new rxjs_1.Subject();
+        this.config = config;
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`TelemetryService(${this.config.url})`);
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe(operators_1.filter((message) => {
+            return message.type === 'telemetry-subscription' && message.url === this.config.url;
+        }))
+            .subscribe((msg) => {
+            this.changeStream$.next(msg.data);
+        });
+        this.streamStatusSubject$ = new rxjs_1.BehaviorSubject({
+            scope: 'default',
+            status: SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED,
+        });
+    }
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * The main method for subscribing to telemetry messages
+     *
+     * @param params - Subscription params
+     *
+     * @returns An Observable that outputs telemetry messages
+     */
+    subscribe(params) {
+        var _a, _b;
+        const sources = (_a = arrayUnique_1.arrayUnique(params.sources).map((item) => item.trim())) !== null && _a !== void 0 ? _a : [];
+        if (!(params === null || params === void 0 ? void 0 : params.callsigns) && (params === null || params === void 0 ? void 0 : params.query)) {
+            this.logger.error('Error: params need to contain either callsigns or query', params);
+            throw new RocosError_1.RocosError('Params need to contain either callsigns or query.', RocosError_1.errorCodes.TELEMETRY_SERVICE_ERROR);
+        }
+        let callsignsLookup = new CallsignsLookup_1.CallsignsLookup([]);
+        if (params === null || params === void 0 ? void 0 : params.callsigns) {
+            this.logger.info('subscribe with callsigns', params);
+            callsignsLookup = new CallsignsLookup_1.CallsignsLookup(params.callsigns);
+        }
+        else if (params === null || params === void 0 ? void 0 : params.query) {
+            this.logger.info('subscribe with query', params);
+            callsignsLookup = new CallsignsLookup_1.CallsignsLookup(params.query);
+        }
+        const scope = (_b = params.scope) !== null && _b !== void 0 ? _b : 'default';
+        const identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_TELEMETRY, scope);
+        const streamRegister = StreamRegister_1.StreamRegister.getInstance();
+        let stream = streamRegister.getStream(identifier);
+        if (!stream) {
+            stream = this.getStream({
+                url: this.config.url,
+                projectId: params.projectId,
+                callsignsLookup,
+                sources,
+                token: this.config.token,
+                scope,
+                options: this.config.options,
+                port: this.config.port,
+                insecure: this.config.insecure,
+            });
+            // don't wait for these promises, they can be init after startup
+            void streamRegister.addStream(stream);
+            void this.initStream(stream);
+            stream.statusStream$.subscribe((msg) => {
+                this.streamStatusSubject$.next({
+                    scope,
+                    status: msg,
+                });
+            });
+        }
+        const subscriptionParams = {
+            uniqueId: getUniqueId_1.getUniqueId(params.projectId, callsignsLookup, sources, scope),
+            callsigns: callsignsLookup && callsignsLookup.lookupType === CallsignsEnums_1.CallsignsLookupType.List
+                ? callsignsLookup.lookupValue
+                : [],
+            sources,
+        };
+        stream.addSubscription(subscriptionParams);
+        const callsigns = callsignsLookup.lookupValue;
+        if (!this.statusSubscription) {
+            this.statusSubscription = stream.statusStream$.subscribe((msg) => {
+                this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+                this.status$.next(msg);
+            });
+        }
+        return rxjs_1.from(stream.messageStream$).pipe(operators_1.filter((message) => {
+            return callsigns.includes(message.callsign) && sources.includes(message.source);
+        }), operators_1.finalize(() => stream === null || stream === void 0 ? void 0 : stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+    }
+    /**
+     * A method to keep track of the current subscriptions
+     *
+     * @returns An Observable that outputs subscription changes
+     */
+    getSubscriptionChanges() {
+        return this.changeStream$.asObservable();
+    }
+    /**
+     * A method to keep track of the stream status
+     *
+     * @returns An Observable that outputs stream status
+     */
+    getStatusChanges() {
+        return this.streamStatusSubject$.asObservable();
+    }
+    async initStream(stream) {
+        // an async callback to set the stream token in case one was not set at startup
+        if (!this.config.token) {
+            try {
+                const authService = RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService();
+                const token = await authService.getToken();
+                if (token === null || token === void 0 ? void 0 : token.value) {
+                    this.config.token = token === null || token === void 0 ? void 0 : token.value;
+                    stream.setToken(this.config.token);
+                }
+            }
+            catch (e) {
+                this.logger.info('Can not retrieve auth token', e);
+            }
+        }
+        stream.init();
+    }
+    getStream(config) {
+        return new TelemetryStream_1.TelemetryStream(config);
+    }
+}
+exports.TelemetryService = TelemetryService;

package/services/TelemetryServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { ITelemetryStream } from '../models/stream/ITelemetryStream';
+import { ITelemetryStreamConfig } from '../models/ITelemetryStreamConfig';
+import { TelemetryService } from './TelemetryService';
+export declare class TelemetryServiceNode extends TelemetryService {
+    protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
+}

package/services/TelemetryServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryServiceNode = void 0;
+const TelemetryService_1 = require("./TelemetryService");
+const TelemetryStreamNode_1 = require("../api/streams/telemetry/TelemetryStreamNode");
+class TelemetryServiceNode extends TelemetryService_1.TelemetryService {
+    getStream(config) {
+        return new TelemetryStreamNode_1.TelemetryStreamNode(config);
+    }
+}
+exports.TelemetryServiceNode = TelemetryServiceNode;

package/services/TimeSyncerService.d.ts

@@ -0,0 +1,13 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+export declare class TimeSyncerService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Get Server Time
+     */
+    getServerTime(): Promise<any>;
+}

package/services/TimeSyncerService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSyncerService = void 0;
+const RocosError_1 = require("../models/RocosError");
+const api_1 = require("../constants/api");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class TimeSyncerService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`TimeSyncerService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.TIME_SYNCER_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Get Server Time
+     */
+    getServerTime() {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SERVER_TIME_URL, { url: this.config.url }, this.config.insecure), 'Failed to get server time.');
+    }
+}
+exports.TimeSyncerService = TimeSyncerService;