@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/services/BaseServiceAbstract.d.ts

@@ -0,0 +1,38 @@
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { Logger } from 'loglevel';
+import { RocosError } from '../models/RocosError';
+declare type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
+declare type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
+declare type Payload = unknown;
+interface RequestConfig {
+    /**
+     * Additional headers to send with the request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * If true, the request will be sent without authentication.
+     */
+    public?: boolean;
+    /**
+     * The response type to use for the request.
+     */
+    responseType?: ResponseType;
+}
+export declare abstract class BaseServiceAbstract {
+    protected config: IRocosSDKConfig;
+    protected logger: Logger;
+    constructor(config: IRocosSDKConfig);
+    protected abstract getError(e: Error): RocosError;
+    protected callPost<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
+    protected callPut<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
+    protected callDelete<T = unknown>(url: string, errorMessage: string, payload?: unknown): Promise<T>;
+    protected callGet<T = unknown>(url: string, errorMessage: string, params?: QueryParams, config?: RequestConfig): Promise<T>;
+    protected call<T = unknown>(url: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: {
+        errorMessage: string;
+        config?: RequestConfig;
+        payload?: unknown;
+        params?: QueryParams;
+    }): Promise<T>;
+    private fetchOrThrow;
+}
+export {};

package/services/BaseServiceAbstract.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServiceAbstract = void 0;
+const RocosError_1 = require("../models/RocosError");
+const RocosStore_1 = require("../store/RocosStore");
+class HttpError extends Error {
+    constructor(response) {
+        super(response.statusText);
+        this.response = response;
+        this.name = 'HttpError';
+    }
+}
+class BaseServiceAbstract {
+    constructor(config) {
+        this.config = config;
+    }
+    async callPost(url, payload, errorMessage, config) {
+        return this.call(url, 'POST', { errorMessage, payload, config });
+    }
+    async callPut(url, payload, errorMessage, config) {
+        return this.call(url, 'PUT', { errorMessage, payload, config });
+    }
+    async callDelete(url, errorMessage, payload) {
+        return this.call(url, 'DELETE', { errorMessage, payload });
+    }
+    async callGet(url, errorMessage, params, config) {
+        return this.call(url, 'GET', { errorMessage, params, config });
+    }
+    async call(url, method, options) {
+        var _a;
+        const { errorMessage, config, payload, params } = options;
+        try {
+            // change all params to string
+            const stringParams = Object.entries(params || {}).reduce((acc, [key, value]) => {
+                acc[key] = value.toString();
+                return acc;
+            }, {});
+            const formattedUrl = params ? `${url}?${new URLSearchParams(stringParams)}` : url;
+            const defaultHeaders = {};
+            if (!(config === null || config === void 0 ? void 0 : config.public)) {
+                const token = await RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService().getToken();
+                defaultHeaders.Authorization = `Bearer ${token.value}`;
+            }
+            const requestConfig = {
+                method,
+                headers: Object.assign(Object.assign({}, defaultHeaders), config === null || config === void 0 ? void 0 : config.headers),
+            };
+            // must check if FormData exists for node support
+            if (typeof FormData !== 'undefined' && payload instanceof FormData) {
+                requestConfig.body = payload;
+            }
+            else if (payload) {
+                requestConfig.body = JSON.stringify(payload);
+                requestConfig.headers = Object.assign(Object.assign({}, requestConfig.headers), { 'Content-Type': 'application/json' });
+            }
+            return this.fetchOrThrow(formattedUrl, requestConfig, config === null || config === void 0 ? void 0 : config.responseType);
+        }
+        catch (e) {
+            const message = errorMessage;
+            this.logger.error(message, e);
+            let httpError = new RocosError_1.RocosError(message);
+            if (e instanceof HttpError) {
+                httpError = this.getError(e);
+                httpError.statusCode = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status;
+            }
+            RocosStore_1.RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
+            throw httpError;
+        }
+    }
+    async fetchOrThrow(url, config, responseType) {
+        this.logger.debug('Fetching', { url, config });
+        const res = await fetch(url, config);
+        if (!res.ok) {
+            const payload = await res.text();
+            this.logger.warn('Failed HTTP Response', { status: res.statusText, payload, response: res });
+            throw new HttpError(res);
+        }
+        switch (responseType) {
+            case 'raw':
+                return res;
+            case 'stream':
+                return res.body;
+            case 'blob':
+                return res.blob();
+            case 'text':
+                return res.text();
+            case 'json':
+            default: {
+                const textRes = await res.text();
+                if (!(textRes === null || textRes === void 0 ? void 0 : textRes.trim()))
+                    return undefined;
+                try {
+                    return JSON.parse(textRes);
+                }
+                catch (e) {
+                    this.logger.error('Failed to parse JSON from response', { textRes });
+                    return textRes;
+                }
+            }
+        }
+    }
+}
+exports.BaseServiceAbstract = BaseServiceAbstract;

package/services/CallerService.d.ts

@@ -0,0 +1,22 @@
+import { ICallerInvokeParams, ICallerParams } from '../models/params/ICallerParams';
+import { Observable, Subject } from 'rxjs';
+import { IBaseService } from '../models/IBaseService';
+import { ICallerStream } from '../models/stream/ICallerStream';
+import { IRocosCallerMessage } from '../models/message/IRocosCallerMessage';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IStreamConfig } from '../models/IStreamConfig';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
+export declare class CallerService implements IBaseService, ISubscriberStatus {
+    private config;
+    private logger;
+    private status;
+    status$: Subject<SubscriberStatusEnum>;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
+    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
+    private createStream;
+    private initStream;
+    protected getStream(config: IStreamConfig): ICallerStream;
+}

package/services/CallerService.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerService = void 0;
+const rxjs_1 = require("rxjs");
+const CallerStream_1 = require("../api/streams/caller/CallerStream");
+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 operators_1 = require("rxjs/operators");
+class CallerService {
+    constructor(config) {
+        this.status = false;
+        this.status$ = new rxjs_1.Subject();
+        this.config = config;
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CallerService(${this.config.url})`);
+    }
+    getStatus() {
+        return this.status;
+    }
+    invokeRequest(params) {
+        const subject = new rxjs_1.Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.invokeRequest(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('invokeRequest error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe(operators_1.finalize(() => {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        }));
+    }
+    cancelRequest(params) {
+        const subject = new rxjs_1.Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.cancelRequest(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('invokeRequest error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe(operators_1.finalize(() => {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        }));
+    }
+    async createStream() {
+        const scope = 'default';
+        const identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_CALLER, scope);
+        const streamRegister = StreamRegister_1.StreamRegister.getInstance();
+        let stream = streamRegister.getStream(identifier);
+        if (!stream) {
+            stream = this.getStream({
+                url: this.config.url,
+                token: this.config.token,
+                scope,
+                options: this.config.options,
+                port: this.config.port,
+                insecure: this.config.insecure,
+            });
+            stream.statusStream$.subscribe((msg) => {
+                this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+                this.status$.next(msg);
+            });
+            // don't wait for these promises, they can be init after startup
+            await streamRegister.addStream(stream);
+            await this.initStream(stream);
+        }
+        return stream;
+    }
+    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);
+            }
+        }
+    }
+    getStream(config) {
+        return new CallerStream_1.CallerStream(config);
+    }
+}
+exports.CallerService = CallerService;

package/services/CallerServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { CallerService } from './CallerService';
+import { ICallerStream } from '../models/stream/ICallerStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+export declare class CallerServiceNode extends CallerService {
+    protected getStream(config: IStreamConfig): ICallerStream;
+}

package/services/CallerServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerServiceNode = void 0;
+const CallerService_1 = require("./CallerService");
+const CallerStreamNode_1 = require("../api/streams/caller/CallerStreamNode");
+class CallerServiceNode extends CallerService_1.CallerService {
+    getStream(config) {
+        return new CallerStreamNode_1.CallerStreamNode(config);
+    }
+}
+exports.CallerServiceNode = CallerServiceNode;

package/services/CommandService.d.ts

@@ -0,0 +1,21 @@
+import { Observable, Subject } from 'rxjs';
+import { IBaseService } from '../models/IBaseService';
+import { ICommandParams } from '../models/params/ICommandParams';
+import { ICommandStream } from '../models/stream/ICommandStream';
+import { IRocosCommandMessage } from '../models/message/IRocosCommandMessage';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IStreamConfig } from '../models/IStreamConfig';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
+export declare class CommandService implements IBaseService, ISubscriberStatus {
+    private config;
+    private logger;
+    private status;
+    status$: Subject<SubscriberStatusEnum>;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    invokeRequest(params: ICommandParams): Observable<IRocosCommandMessage>;
+    private createStream;
+    private initStream;
+    protected getStream(config: IStreamConfig): ICommandStream;
+}

package/services/CommandService.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandService = void 0;
+const rxjs_1 = require("rxjs");
+const CommandStream_1 = require("../api/streams/command/CommandStream");
+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 operators_1 = require("rxjs/operators");
+class CommandService {
+    constructor(config) {
+        this.status = false;
+        this.status$ = new rxjs_1.Subject();
+        this.config = config;
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CommandService(${this.config.url})`);
+    }
+    getStatus() {
+        return this.status;
+    }
+    invokeRequest(params) {
+        const subject = new rxjs_1.Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.invokeRequest(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('invokeRequest error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe(operators_1.finalize(() => {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        }));
+    }
+    async createStream() {
+        const scope = 'default';
+        const identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_COMMAND, scope);
+        const streamRegister = StreamRegister_1.StreamRegister.getInstance();
+        let stream = streamRegister.getStream(identifier);
+        if (!stream) {
+            stream = this.getStream({
+                url: this.config.url,
+                token: this.config.token,
+                scope,
+                options: this.config.options,
+                port: this.config.port,
+                insecure: this.config.insecure,
+            });
+            stream.statusStream$.subscribe((msg) => {
+                this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+                this.status$.next(msg);
+            });
+            // don't wait for these promises, they can be init after startup
+            await streamRegister.addStream(stream);
+            await this.initStream(stream);
+        }
+        return stream;
+    }
+    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);
+            }
+        }
+    }
+    getStream(config) {
+        return new CommandStream_1.CommandStream(config);
+    }
+}
+exports.CommandService = CommandService;

package/services/CommandServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { CommandService } from './CommandService';
+import { ICommandStream } from '../models/stream/ICommandStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+export declare class CommandServiceNode extends CommandService {
+    protected getStream(config: IStreamConfig): ICommandStream;
+}

package/services/CommandServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandServiceNode = void 0;
+const CommandService_1 = require("./CommandService");
+const CommandStreamNode_1 = require("../api/streams/command/CommandStreamNode");
+class CommandServiceNode extends CommandService_1.CommandService {
+    getStream(config) {
+        return new CommandStreamNode_1.CommandStreamNode(config);
+    }
+}
+exports.CommandServiceNode = CommandServiceNode;

package/services/ConfigGroupService.d.ts

@@ -0,0 +1,89 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IConfigGroup } from '../models/IConfigGroup';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+export declare class ConfigGroupService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Create a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param model - Payload {@link IConfigGroup}
+     */
+    create(projectId: string, type: string, model: IConfigGroup): Promise<any>;
+    /**
+     * Get a config group list
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     */
+    list(projectId: string, type: string): Promise<any>;
+    /**
+     * Update a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    update(projectId: string, type: string, configGroupId: string, model: IConfigGroup): Promise<any>;
+    /**
+     * Get a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     */
+    info(projectId: string, type: string, configGroupId: string): Promise<any>;
+    /**
+     * Publish a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    publish(projectId: string, type: string, configGroupId: string, model: IConfigGroup): Promise<any>;
+    /**
+     * Update a config
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param configId - Config Id
+     * @param content - Payload
+     */
+    updateConfig(projectId: string, type: string, configGroupId: string, configId: string, content: any): Promise<any>;
+    /**
+     * Get a config group by version
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param version - Version
+     */
+    getByVersion(projectId: string, type: string, configGroupId: string, version: string): Promise<any>;
+    /**
+     * Override a config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     * @param content - Payload
+     */
+    overrideByOwnerId(projectId: string, type: string, configGroupId: string, ownerId: string, content: any): Promise<any>;
+    /**
+     * Get an override config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     */
+    getOverrideConfig(projectId: string, type: string, configGroupId: string, ownerId: string): Promise<any>;
+}

package/services/ConfigGroupService.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigGroupService = 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 formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class ConfigGroupService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`ConfigGroupService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.CONFIG_GROUP_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async create(projectId, type, model) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_URL, { url: this.config.url, projectId, type }, this.config.insecure), model, `Failed to create config group for ${projectId}, type ${type}.`);
+    }
+    /**
+     * Get a config group list
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     */
+    // TODO: map the response object
+    async list(projectId, type) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_URL, { url: this.config.url, projectId, type }, this.config.insecure), `Failed to get config group list for ${projectId}, type ${type}.`);
+    }
+    /**
+     * Update a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async update(projectId, type, configGroupId, model) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_ID_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), model, `Failed to update config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Get a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     */
+    // TODO: map the response object
+    async info(projectId, type, configGroupId) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_ID_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), `Failed to get config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Publish a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async publish(projectId, type, configGroupId, model) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_PUBLISH_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), model, `Failed to publish config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Update a config
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param configId - Config Id
+     * @param content - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    async updateConfig(projectId, type, configGroupId, configId, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    content) {
+        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_CONFIG_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            configId,
+        }, this.config.insecure), content, `Failed to update config for ${projectId}, type ${type}, configGroupId ${configGroupId}, configId ${configId}.`);
+    }
+    /**
+     * Get a config group by version
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param version - Version
+     */
+    // TODO: map the response object
+    async getByVersion(projectId, type, configGroupId, version) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_VERSION_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            version,
+        }, this.config.insecure), `Failed to get config group for ${projectId}, type ${type}, configGroupId ${configGroupId}, version ${version}.`);
+    }
+    /**
+     * Override a config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     * @param content - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    async overrideByOwnerId(projectId, type, configGroupId, ownerId, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    content) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_OWNER_OVERRIDE_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            ownerId,
+        }, this.config.insecure), content, `Failed to override for ${projectId}, type ${type}, configGroupId ${configGroupId}, ownerId ${ownerId}.`);
+    }
+    /**
+     * Get an override config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     */
+    // TODO: map the response object
+    async getOverrideConfig(projectId, type, configGroupId, ownerId) {
+        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_GROUP_TYPE_OWNER_ID_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            ownerId,
+        }, this.config.insecure), `Failed to get override for ${projectId}, type ${type}, configGroupId ${configGroupId}, ownerId ${ownerId}.`);
+    }
+}
+exports.ConfigGroupService = ConfigGroupService;

package/services/ControlService.d.ts

@@ -0,0 +1,23 @@
+import { ControlActionType, IControlParams } from '../models/params/IControlParams';
+import { Observable, Subject } from 'rxjs';
+import { IBaseService } from '../models/IBaseService';
+import { IControlStream } from '../models/stream/IControlStream';
+import { IRocosControlMessage } from '../models/message/IRocosControlMessage';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IStreamConfig } from '../models/IStreamConfig';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
+export declare class ControlService implements IBaseService, ISubscriberStatus {
+    private config;
+    private logger;
+    private status;
+    status$: Subject<SubscriberStatusEnum>;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    takeActionWithAck(action: ControlActionType, params: IControlParams, ackTimeoutInSeconds?: number): Observable<string>;
+    sendCommand(params: IControlParams): Promise<void>;
+    sendCommandWithAck(params: IControlParams): Observable<IRocosControlMessage>;
+    private createStream;
+    private initStream;
+    protected getStream(config: IStreamConfig): IControlStream;
+}