@hahnpro/hpc-api 5.3.4 → 2024.4.0-0

package/package.json

@@ -1,28 +1,12 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "5.3.4",
-  "description": "Module for easy access to the HahnPRO API",
+  "version": "2024.4.0-0",
+  "description": "Module for easy access to the HahnPRO Cloud API",
   "license": "MIT",
   "author": {
     "name": "Hahn Projects GmbH",
     "url": "https://hahnpro.com"
   },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:hahnprojects/flow.git"
-  },
-  "directories": {
-    "lib": "lib",
-    "test": "test"
-  },
-  "files": [
-    "dist"
-  ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "axios": "1.7.9",
     "eventsource": "2.0.2",
@@ -31,17 +15,17 @@
     "jwt-decode": "4.0.0",
     "p-queue": "6.6.2",
     "ts-mixer": "6.0.4",
-    "uuid": "11.0.5"
+    "tslib": "2.8.1"
   },
   "devDependencies": {
     "@types/eventsource": "1.1.15",
     "axios-mock-adapter": "2.1.0"
   },
   "engines": {
-    "node": ">=v18"
+    "node": ">=v20"
   },
-  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p tsconfig.lib.json",
-    "build:nocomments": "../../node_modules/.bin/tsc -p tsconfig.nocomments.json"
-  }
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "module": "./lib/hpc-api/src/index.js",
+  "type": "module"
 }

package/src/index.d.ts

@@ -0,0 +1,20 @@
+export * from './lib/api';
+export * from './lib/asset.interface';
+export * from './lib/content.interface';
+export * from './lib/data.interface';
+export * from './lib/data.service';
+export * from './lib/endpoint.interface';
+export * from './lib/events.interface';
+export * from './lib/flow.interface';
+export * from './lib/flow-deployment.interface';
+export * from './lib/flow-function.interface';
+export * from './lib/http.service';
+export * from './lib/label.interface';
+export * from './lib/mock';
+export * from './lib/notification.interface';
+export * from './lib/resource.interface';
+export * from './lib/schema.interface';
+export * from './lib/secret.interface';
+export * from './lib/task.interface';
+export * from './lib/timeseries.interface';
+export * from './lib/vault.interface';

package/src/index.js

@@ -0,0 +1,20 @@
+export * from './lib/api';
+export * from './lib/asset.interface';
+export * from './lib/content.interface';
+export * from './lib/data.interface';
+export * from './lib/data.service';
+export * from './lib/endpoint.interface';
+export * from './lib/events.interface';
+export * from './lib/flow.interface';
+export * from './lib/flow-deployment.interface';
+export * from './lib/flow-function.interface';
+export * from './lib/http.service';
+export * from './lib/label.interface';
+export * from './lib/mock';
+export * from './lib/notification.interface';
+export * from './lib/resource.interface';
+export * from './lib/schema.interface';
+export * from './lib/secret.interface';
+export * from './lib/task.interface';
+export * from './lib/timeseries.interface';
+export * from './lib/vault.interface';

package/{dist → src/lib}/Queue.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-const tslib_1 = require("tslib");
-const p_queue_1 = tslib_1.__importDefault(require("p-queue"));
-class Queue extends p_queue_1.default {
+import PQueue from 'p-queue';
+export class Queue extends PQueue {
     constructor(options) {
         super(options);
         this.peak = 0;
@@ -24,4 +20,3 @@ class Queue extends p_queue_1.default {
         };
     }
 }
-exports.Queue = Queue;

package/src/lib/api-base.js

@@ -0,0 +1,6 @@
+export class APIBase {
+    constructor(httpClient, basePath) {
+        this.httpClient = httpClient;
+        this.basePath = basePath;
+    }
+}

package/src/lib/api.js

@@ -0,0 +1,60 @@
+import { AssetService } from './asset.service';
+import { AssetTypesService } from './assettypes.service';
+import { ContentService } from './content.service';
+import { EndpointService } from './endpoint.service';
+import { EventsService } from './events.service';
+import { FlowDeploymentService } from './flow-deployment.service';
+import { FlowFunctionService } from './flow-function.service';
+import { FlowModuleService } from './flow-module.service';
+import { FlowService } from './flow.service';
+import { HttpClient } from './http.service';
+import { LabelService } from './label.service';
+import { NotificationService } from './notification.service';
+import { ProxyService } from './proxy.service';
+import { SecretService } from './secret.service';
+import { TaskService } from './task.service';
+import { TimeSeriesService } from './timeseries.service';
+import { UserService } from './user.service';
+import { VaultService } from './vault.service';
+export class API {
+    constructor(httpClient, context) {
+        this.httpClient = httpClient;
+        if (!httpClient) {
+            // remove leading and trailing slashes
+            const normalizePath = (value = '', defaultValue = '') => value.replace(/(?:^\/+)|(?:\/+$)/g, '') || defaultValue;
+            let apiBaseUrl = process.env.API_BASE_URL || 'https://testing.hahnpro.com';
+            if (!apiBaseUrl.startsWith('https') && !apiBaseUrl.startsWith('http')) {
+                /* eslint-disable-next-line no-console */
+                console.info('no protocol specified - using HTTPS');
+                apiBaseUrl = `https://${apiBaseUrl}`;
+            }
+            const apiUrl = apiBaseUrl + '/' + normalizePath(process.env.API_BASE_PATH, 'api');
+            const authBaseUrl = process.env.AUTH_BASE_URL || apiBaseUrl;
+            const authUrl = authBaseUrl + '/' + normalizePath(process.env.AUTH_BASE_PATH, 'auth');
+            const realm = process.env.AUTH_REALM || 'hpc';
+            const client = process.env.API_USER || 'flow-executor-service';
+            const secret = process.env.AUTH_SECRET;
+            if (!secret) {
+                throw new Error('"API_BASE_URL", "API_USER", "AUTH_REALM" and "AUTH_SECRET" environment variables must be set');
+            }
+            this.httpClient = new HttpClient(apiUrl, authUrl, realm, client, secret, context?.tokenSubject);
+        }
+        this.assets = new AssetService(this.httpClient);
+        this.assetTypes = new AssetTypesService(this.httpClient);
+        this.contents = new ContentService(this.httpClient);
+        this.endpoints = new EndpointService(this.httpClient);
+        this.events = new EventsService(this.httpClient);
+        this.flows = new FlowService(this.httpClient);
+        this.flowDeployments = new FlowDeploymentService(this.httpClient);
+        this.flowFunctions = new FlowFunctionService(this.httpClient);
+        this.flowModules = new FlowModuleService(this.httpClient);
+        this.labels = new LabelService(this.httpClient);
+        this.proxy = new ProxyService(this.httpClient);
+        this.secrets = new SecretService(this.httpClient);
+        this.tasks = new TaskService(this.httpClient);
+        this.timeSeries = new TimeSeriesService(this.httpClient);
+        this.users = new UserService(this.httpClient);
+        this.vault = new VaultService(this.httpClient);
+        this.notifications = new NotificationService(this.httpClient);
+    }
+}

package/src/lib/asset.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/asset.service.d.ts

@@ -0,0 +1,24 @@
+import FormData from 'form-data';
+import { APIBase } from './api-base';
+import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from './asset.interface';
+import { Paginated, RequestParameter } from './data.interface';
+import { DataService } from './data.service';
+import { HttpClient, TokenOption } from './http.service';
+import { TrashService } from './trash.service';
+interface BaseService extends DataService<Asset>, TrashService<Asset> {
+}
+declare class BaseService extends APIBase {
+}
+export declare class AssetService extends BaseService {
+    constructor(httpClient: HttpClient);
+    deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
+    addAttachment: (id: string, form: FormData, options?: TokenOption) => Promise<Asset>;
+    getChildren(assetId: string, params?: RequestParameter, options?: TokenOption): Promise<Paginated<Asset[]>>;
+    getAttachments(assetId: string, options?: TokenOption): Promise<Paginated<Attachment[]>>;
+    getEventLevelOverride(ids: string[], causes: string[], options?: TokenOption): Promise<EventLevelOverride>;
+    updateEventCausesAsset(id: string, dto: EventCause, options?: TokenOption): Promise<Asset>;
+    getRevisions(assetId: string, options?: TokenOption): Promise<Paginated<AssetRevision[]>>;
+    rollback(assetId: string, revisionId: string, options?: TokenOption): Promise<Asset>;
+    deleteRevision(assetId: string, revisionId: string, options?: TokenOption): Promise<any>;
+}
+export {};

package/src/lib/asset.service.js

@@ -0,0 +1,51 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class AssetService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/assets');
+        this.addAttachment = (id, form, options = {}) => {
+            const headers = { ...form.getHeaders() };
+            return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, {
+                headers,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                ...options,
+            });
+        };
+    }
+    deleteOne(id, force = false, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
+    }
+    getChildren(assetId, params = {}, options = {}) {
+        return this.getManyFiltered({ parent: assetId }, params, options);
+    }
+    getAttachments(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${assetId}/attachments`, options);
+    }
+    getEventLevelOverride(ids, causes, options = {}) {
+        return this.httpClient.get(`${this.basePath}/eventcauses`, {
+            params: { ids: ids.join(','), causes: causes.join(',') },
+            ...options,
+        });
+    }
+    updateEventCausesAsset(id, dto, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/eventcauses`, dto, options);
+    }
+    getRevisions(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${assetId}/revisions`, options);
+    }
+    rollback(assetId, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${assetId}/rollback`, { revisionId }, options);
+    }
+    deleteRevision(assetId, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`, options);
+    }
+}

package/{dist → src/lib}/assettypes.service.d.ts

@@ -2,7 +2,7 @@ import { APIBase } from './api-base';
 import { AssetType } from './asset.interface';
 import { Paginated } from './data.interface';
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<AssetType>, TrashService<AssetType> {
 }
@@ -10,8 +10,8 @@ declare class BaseService extends APIBase {
 }
 export declare class AssetTypesService extends BaseService {
     constructor(httpClient: HttpClient);
-    getRevisions(id: string): Promise<Paginated<AssetType[]>>;
-    rollback(id: string, revisionId: string): Promise<AssetType>;
-    deleteRevision(id: string, revisionId: string): Promise<any>;
+    getRevisions(id: string, options?: TokenOption): Promise<Paginated<AssetType[]>>;
+    rollback(id: string, revisionId: string, options?: TokenOption): Promise<AssetType>;
+    deleteRevision(id: string, revisionId: string, options?: TokenOption): Promise<any>;
 }
 export {};

package/src/lib/assettypes.service.js

@@ -0,0 +1,24 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class AssetTypesService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/assettypes');
+    }
+    getRevisions(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/revisions`, options);
+    }
+    rollback(id, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId }, options);
+    }
+    deleteRevision(id, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`, options);
+    }
+}

package/{dist → src/lib}/content.interface.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturnType = void 0;
-var ReturnType;
+export var ReturnType;
 (function (ReturnType) {
     ReturnType[ReturnType["TEXT"] = 0] = "TEXT";
     ReturnType[ReturnType["JSON"] = 1] = "JSON";
@@ -9,4 +6,4 @@ var ReturnType;
     ReturnType[ReturnType["BLOB"] = 3] = "BLOB";
     ReturnType[ReturnType["ARRAYBUFFER"] = 4] = "ARRAYBUFFER";
     ReturnType[ReturnType["NODESTREAM"] = 5] = "NODESTREAM";
-})(ReturnType || (exports.ReturnType = ReturnType = {}));
+})(ReturnType || (ReturnType = {}));

package/src/lib/content.service.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'stream';
+import FormData from 'form-data';
+import { APIBase } from './api-base';
+import { Content, ReturnType } from './content.interface';
+import { DataService } from './data.service';
+import { HttpClient, TokenOption } from './http.service';
+import { TrashService } from './trash.service';
+interface BaseService extends DataService<Content>, TrashService<Content> {
+}
+declare class BaseService extends APIBase {
+}
+export declare class ContentService extends BaseService {
+    constructor(httpClient: HttpClient);
+    upload: (form: FormData, options?: TokenOption) => Promise<Content>;
+    download(id: string, raw?: boolean, options?: TokenOption): Promise<Blob | ArrayBuffer>;
+    download(id: string, returnType: ReturnType.TEXT, options?: TokenOption): Promise<string>;
+    download(id: string, returnType: ReturnType.JSON, options?: TokenOption): Promise<Record<string, unknown>>;
+    download(id: string, returnType: ReturnType.NODEBUFFER, options?: TokenOption): Promise<Buffer>;
+    download(id: string, returnType: ReturnType.BLOB, options?: TokenOption): Promise<Blob>;
+    download(id: string, returnType: ReturnType.ARRAYBUFFER, options?: TokenOption): Promise<ArrayBuffer>;
+    download(id: string, returnType: ReturnType.NODESTREAM, options?: TokenOption): Promise<Readable>;
+}
+export {};

package/src/lib/content.service.js

@@ -0,0 +1,49 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { ReturnType } from './content.interface';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class ContentService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/contents');
+        this.upload = (form, options = {}) => {
+            const headers = { ...form.getHeaders() };
+            return this.httpClient.post(`${this.basePath}`, form, {
+                headers,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                ...options,
+            });
+        };
+    }
+    async download(id, second, options = {}) {
+        let returnType;
+        if (typeof second === 'boolean' || second == null) {
+            returnType = second ? ReturnType.ARRAYBUFFER : ReturnType.BLOB;
+        }
+        else {
+            returnType = second;
+        }
+        const url = `${this.basePath}/${id}/download`;
+        switch (returnType) {
+            case ReturnType.TEXT:
+                return this.httpClient.get(url, { responseType: 'text', ...options });
+            case ReturnType.JSON:
+                return this.httpClient.get(url, { responseType: 'json', ...options });
+            case ReturnType.NODEBUFFER:
+                return Buffer.from(new Uint8Array(await this.httpClient.get(url, { responseType: 'arraybuffer', ...options })));
+            case ReturnType.BLOB:
+                return this.httpClient.get(url, { responseType: 'blob', ...options });
+            case ReturnType.ARRAYBUFFER:
+                return this.httpClient.get(url, { responseType: 'arraybuffer', ...options });
+            case ReturnType.NODESTREAM:
+                return this.httpClient.get(url, { responseType: 'stream', ...options });
+        }
+    }
+}

package/src/lib/data.interface.d.ts

@@ -0,0 +1,38 @@
+import { TokenOption } from './http.service';
+export interface Paginated<T> {
+    docs: T;
+    total: number;
+    limit: number;
+    page?: number;
+    pages?: number;
+    offset?: number;
+}
+export interface RequestParameter {
+    filter?: string;
+    limit?: number;
+    page?: number;
+    populate?: string;
+    sort?: string;
+}
+interface TimePeriod {
+    from: Date;
+    to: Date;
+}
+export declare function instanceOfTimePeriod(object: any): object is TimePeriod;
+export type Filter = Record<string, string | string[] | TimePeriod>;
+export interface DataInterface<T> {
+    addOne(dto: any, options?: TokenOption): Promise<T>;
+    addMany(dto: any[], options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<T[]>;
+    getOne(id: string, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<T>;
+    getMany(params?: RequestParameter, options?: TokenOption): Promise<Paginated<T[]>>;
+    getManyFiltered(filter: Filter, params?: RequestParameter, options?: TokenOption): Promise<Paginated<T[]>>;
+    updateOne(id: string, dto: any, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<T>;
+    deleteOne(id: string, force: boolean, options?: TokenOption): Promise<any>;
+}
+export {};

package/src/lib/data.interface.js

@@ -0,0 +1,3 @@
+export function instanceOfTimePeriod(object) {
+    return 'from' in object && 'to' in object;
+}

package/src/lib/data.service.d.ts

@@ -0,0 +1,27 @@
+import { APIBase } from './api-base';
+import { DataInterface, Filter, Paginated, RequestParameter } from './data.interface';
+import { TokenOption } from './http.service';
+export declare class DataService<T> extends APIBase implements DataInterface<T> {
+    addOne(dto: any, options?: TokenOption): Promise<T>;
+    addMany(dto: any[], options?: TokenOption): Promise<T[]>;
+    getOne(id: string, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<T>;
+    getMany(params?: RequestParameter, options?: TokenOption): Promise<Paginated<T[]>>;
+    /**
+     * Filters the elements by the passed properties. The object with these properties has to be of the form:
+     * {
+     *   propertyName: string | string[] | { from: Date, to: Date },
+     *   ...
+     * }.
+     * @param filter The Object with the properties to filter by.
+     * @param params Other request parameters.
+     * @param options Parameters for authentication
+     */
+    getManyFiltered(filter: Filter, params?: RequestParameter, options?: TokenOption): Promise<Paginated<T[]>>;
+    updateOne(id: string, dto: any, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<T>;
+    deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
+    private getFilterString;
+}

package/src/lib/data.service.js

@@ -0,0 +1,57 @@
+import { APIBase } from './api-base';
+import { instanceOfTimePeriod } from './data.interface';
+export class DataService extends APIBase {
+    addOne(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
+    }
+    addMany(dto, options = {}) {
+        return this.httpClient.post(`${this.basePath}/many`, dto, options);
+    }
+    getOne(id, options = {}) {
+        const params = options.populate ? { populate: options.populate } : {};
+        return this.httpClient.get(`${this.basePath}/${id}`, { params });
+    }
+    getMany(params = {}, options = {}) {
+        params.limit = params.limit || 0;
+        params.page = params.page || 1;
+        return this.httpClient.get(`${this.basePath}`, { params, ...options });
+    }
+    /**
+     * Filters the elements by the passed properties. The object with these properties has to be of the form:
+     * {
+     *   propertyName: string | string[] | { from: Date, to: Date },
+     *   ...
+     * }.
+     * @param filter The Object with the properties to filter by.
+     * @param params Other request parameters.
+     * @param options Parameters for authentication
+     */
+    getManyFiltered(filter, params = {}, options = {}) {
+        params.filter = this.getFilterString(filter);
+        return this.getMany(params, options);
+    }
+    updateOne(id, dto, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}`, dto, options);
+    }
+    deleteOne(id, force = false, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
+    }
+    getFilterString(filter) {
+        const filters = [];
+        for (const [key, value] of Object.entries(filter)) {
+            if (value != null && value !== '') {
+                // filter out null and undefined values and empty strings
+                if (typeof value === 'object' && instanceOfTimePeriod(value)) {
+                    filters.push(`${key}>=${value.from.toISOString()};${key}<=${value.to.toISOString()}`);
+                }
+                else if (Array.isArray(value)) {
+                    filters.push(`${key}=@${value.join(',')}`);
+                }
+                else {
+                    filters.push(`${key}==${value}`);
+                }
+            }
+        }
+        return filters.join(';');
+    }
+}

package/src/lib/endpoint.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/endpoint.service.d.ts

@@ -0,0 +1,8 @@
+import { DataService } from './data.service';
+import { Endpoint, EndpointLog, NotificationPayload } from './endpoint.interface';
+import { HttpClient, TokenOption } from './http.service';
+export declare class EndpointService extends DataService<Endpoint> {
+    constructor(httpClient: HttpClient);
+    sendNotification(endpointId: string, payload: NotificationPayload, options?: TokenOption): Promise<void>;
+    readLastLogByGroup(endpointId: string, group: string, options?: TokenOption): Promise<EndpointLog>;
+}

package/src/lib/endpoint.service.js

@@ -0,0 +1,12 @@
+import { DataService } from './data.service';
+export class EndpointService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/notification/endpoints');
+    }
+    sendNotification(endpointId, payload, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${endpointId}`, payload, options);
+    }
+    readLastLogByGroup(endpointId, group, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${endpointId}/logs/${group}/last`, options);
+    }
+}

package/src/lib/events.interface.js

@@ -0,0 +1 @@
+export {};

package/{dist → src/lib}/events.service.d.ts

@@ -1,7 +1,7 @@
 import { DataService } from './data.service';
 import { Event } from './events.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 export declare class EventsService extends DataService<Event> {
     constructor(httpClient: HttpClient);
-    getLastEventByAssetAndGroup(assetId: string, group: string): Promise<Event>;
+    getLastEventByAssetAndGroup(assetId: string, group: string, options?: TokenOption): Promise<Event>;
 }

package/src/lib/events.service.js

@@ -0,0 +1,9 @@
+import { DataService } from './data.service';
+export class EventsService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/events');
+    }
+    getLastEventByAssetAndGroup(assetId, group, options = {}) {
+        return this.httpClient.get(`${this.basePath}/last/${assetId}/${group}`, options);
+    }
+}

package/src/lib/flow-deployment.interface.js

@@ -0,0 +1 @@
+export {};

package/{dist → src/lib}/flow-deployment.service.d.ts

@@ -1,7 +1,7 @@
 import { APIBase } from './api-base';
 import { DataService } from './data.service';
 import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from './flow-deployment.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { ResourceReference } from './resource.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<FlowDeployment>, TrashService<FlowDeployment> {
@@ -10,15 +10,17 @@ declare class BaseService extends APIBase {
 }
 export declare class FlowDeploymentService extends BaseService {
     constructor(httpClient: HttpClient);
-    addMany(dto: any[]): Promise<FlowDeployment[]>;
-    updateOne(id: string, dto: any, force?: boolean): Promise<FlowDeployment>;
-    getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
-    getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;
-    getDeploymentLogs(id: string): Promise<FlowLog[]>;
-    resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
-    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted' | 'paused'): Promise<FlowDeployment>;
-    deleteOne(id: string): Promise<FlowDeployment>;
-    waitForRunningStatus(id: string): Promise<void>;
+    addMany(dto: any[], options?: TokenOption): Promise<FlowDeployment[]>;
+    updateOne(id: string, dto: any, options?: TokenOption & {
+        force: boolean;
+    }): Promise<FlowDeployment>;
+    getDeploymentStatistics(id: string, options?: TokenOption): Promise<FlowDeploymentStatistic>;
+    getDeploymentMetrics(id: string, range?: string, interval?: string, options?: TokenOption): Promise<FlowDeploymentMetrics>;
+    getDeploymentLogs(id: string, options?: TokenOption): Promise<FlowLog[]>;
+    resolveReferences(id: string, recursive?: boolean, types?: string[], options?: TokenOption): Promise<ResourceReference[]>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted' | 'paused', options?: TokenOption): Promise<FlowDeployment>;
+    deleteOne(id: string, _force?: boolean, options?: TokenOption): Promise<FlowDeployment>;
+    waitForRunningStatus(id: string, options?: TokenOption): Promise<void>;
     addOne(dto: {
         diagramId: string;
         name: string;
@@ -26,8 +28,8 @@ export declare class FlowDeploymentService extends BaseService {
         readPermissions?: string[];
         readWritePermissions?: string[];
         tags?: string[];
-    }): Promise<FlowDeployment>;
-    subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
-    subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    }, options?: TokenOption): Promise<FlowDeployment>;
+    subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
+    subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
 }
 export {};