@hahnpro/hpc-api 5.3.4 → 6.0.0

package/dist/asset.service.d.ts

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

@@ -14,40 +14,34 @@ BaseService = tslib_1.__decorate([
 class AssetService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assets');
-        this.addAttachment = (id, form) => {
+        this.addAttachment = (id, form, options = {}) => {
             const headers = Object.assign({}, form.getHeaders());
-            return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, {
-                headers,
-                maxBodyLength: Infinity,
-                maxContentLength: Infinity,
-            });
+            return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, Object.assign({ headers, maxBodyLength: Infinity, maxContentLength: Infinity }, options));
         };
     }
-    deleteOne(id, force = false) {
-        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force } });
+    deleteOne(id, force = false, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}`, Object.assign({ params: { force } }, options));
     }
-    getChildren(assetId, params = {}) {
-        return this.getManyFiltered({ parent: assetId }, params);
+    getChildren(assetId, params = {}, options = {}) {
+        return this.getManyFiltered({ parent: assetId }, params, options);
     }
-    getAttachments(assetId) {
-        return this.httpClient.get(`${this.basePath}/${assetId}/attachments`);
+    getAttachments(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${assetId}/attachments`, options);
     }
-    getEventLevelOverride(ids, causes) {
-        return this.httpClient.get(`${this.basePath}/eventcauses`, {
-            params: { ids: ids.join(','), causes: causes.join(',') },
-        });
+    getEventLevelOverride(ids, causes, options = {}) {
+        return this.httpClient.get(`${this.basePath}/eventcauses`, Object.assign({ params: { ids: ids.join(','), causes: causes.join(',') } }, options));
     }
-    updateEventCausesAsset(id, dto) {
-        return this.httpClient.put(`${this.basePath}/${id}/eventcauses`, dto);
+    updateEventCausesAsset(id, dto, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/eventcauses`, dto, options);
     }
-    getRevisions(assetId) {
-        return this.httpClient.get(`${this.basePath}/${assetId}/revisions`);
+    getRevisions(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${assetId}/revisions`, options);
     }
-    rollback(assetId, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${assetId}/rollback`, { revisionId });
+    rollback(assetId, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${assetId}/rollback`, { revisionId }, options);
     }
-    deleteRevision(assetId, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`);
+    deleteRevision(assetId, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`, options);
     }
 }
 exports.AssetService = AssetService;

package/dist/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/dist/assettypes.service.js

@@ -15,14 +15,14 @@ class AssetTypesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assettypes');
     }
-    getRevisions(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/revisions`);
+    getRevisions(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/revisions`, options);
     }
-    rollback(id, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId });
+    rollback(id, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId }, options);
     }
-    deleteRevision(id, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`);
+    deleteRevision(id, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`, options);
     }
 }
 exports.AssetTypesService = AssetTypesService;

package/dist/content.service.d.ts

@@ -3,7 +3,7 @@ import { Readable } from 'stream';
 import { APIBase } from './api-base';
 import { Content, ReturnType } from './content.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<Content>, TrashService<Content> {
 }
@@ -11,13 +11,13 @@ declare class BaseService extends APIBase {
 }
 export declare class ContentService extends BaseService {
     constructor(httpClient: HttpClient);
-    upload: (form: FormData) => Promise<Content>;
-    download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
-    download(id: string, returnType: ReturnType.TEXT): Promise<string>;
-    download(id: string, returnType: ReturnType.JSON): Promise<Record<string, unknown>>;
-    download(id: string, returnType: ReturnType.NODEBUFFER): Promise<Buffer>;
-    download(id: string, returnType: ReturnType.BLOB): Promise<Blob>;
-    download(id: string, returnType: ReturnType.ARRAYBUFFER): Promise<ArrayBuffer>;
-    download(id: string, returnType: ReturnType.NODESTREAM): Promise<Readable>;
+    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/dist/content.service.js

@@ -15,13 +15,13 @@ BaseService = tslib_1.__decorate([
 class ContentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/contents');
-        this.upload = (form) => {
+        this.upload = (form, options = {}) => {
             const headers = Object.assign({}, form.getHeaders());
-            return this.httpClient.post(`${this.basePath}`, form, { headers, maxBodyLength: Infinity, maxContentLength: Infinity });
+            return this.httpClient.post(`${this.basePath}`, form, Object.assign({ headers, maxBodyLength: Infinity, maxContentLength: Infinity }, options));
         };
     }
-    download(id, second) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+    download(id_1, second_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (id, second, options = {}) {
             let returnType;
             if (typeof second === 'boolean' || second == null) {
                 returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
@@ -32,17 +32,17 @@ class ContentService extends BaseService {
             const url = `${this.basePath}/${id}/download`;
             switch (returnType) {
                 case content_interface_1.ReturnType.TEXT:
-                    return this.httpClient.get(url, { responseType: 'text' });
+                    return this.httpClient.get(url, Object.assign({ responseType: 'text' }, options));
                 case content_interface_1.ReturnType.JSON:
-                    return this.httpClient.get(url, { responseType: 'json' });
+                    return this.httpClient.get(url, Object.assign({ responseType: 'json' }, options));
                 case content_interface_1.ReturnType.NODEBUFFER:
-                    return Buffer.from(new Uint8Array(yield this.httpClient.get(url, { responseType: 'arraybuffer' })));
+                    return Buffer.from(new Uint8Array(yield this.httpClient.get(url, Object.assign({ responseType: 'arraybuffer' }, options))));
                 case content_interface_1.ReturnType.BLOB:
-                    return this.httpClient.get(url, { responseType: 'blob' });
+                    return this.httpClient.get(url, Object.assign({ responseType: 'blob' }, options));
                 case content_interface_1.ReturnType.ARRAYBUFFER:
-                    return this.httpClient.get(url, { responseType: 'arraybuffer' });
+                    return this.httpClient.get(url, Object.assign({ responseType: 'arraybuffer' }, options));
                 case content_interface_1.ReturnType.NODESTREAM:
-                    return this.httpClient.get(url, { responseType: 'stream' });
+                    return this.httpClient.get(url, Object.assign({ responseType: 'stream' }, options));
             }
         });
     }

package/dist/data.interface.d.ts

@@ -1,3 +1,4 @@
+import { TokenOption } from './http.service';
 export interface Paginated<T> {
     docs: T;
     total: number;
@@ -20,12 +21,18 @@ interface TimePeriod {
 export declare function instanceOfTimePeriod(object: any): object is TimePeriod;
 export type Filter = Record<string, string | string[] | TimePeriod>;
 export interface DataInterface<T> {
-    addOne(dto: any): Promise<T>;
-    addMany(dto: any[]): Promise<T[]>;
-    getOne(id: string, options?: any): Promise<T>;
-    getMany(params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
-    getManyFiltered(filter: Filter, params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
-    updateOne(id: string, dto: any): Promise<T>;
-    deleteOne(id: string): Promise<any>;
+    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/dist/data.service.d.ts

@@ -1,10 +1,13 @@
 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): Promise<T>;
-    addMany(dto: any[]): Promise<T[]>;
-    getOne(id: string, options?: any): Promise<T>;
-    getMany(params?: RequestParameter): Promise<Paginated<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:
      * {
@@ -13,9 +16,12 @@ export declare class DataService<T> extends APIBase implements DataInterface<T>
      * }.
      * @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): Promise<Paginated<T[]>>;
-    updateOne(id: string, dto: any): Promise<T>;
-    deleteOne(id: string, force?: boolean): Promise<any>;
+    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/dist/data.service.js

@@ -4,30 +4,30 @@ exports.DataService = void 0;
 const api_base_1 = require("./api-base");
 const data_interface_1 = require("./data.interface");
 class DataService extends api_base_1.APIBase {
-    addOne(dto) {
-        return this.httpClient.post(this.basePath, dto);
+    addOne(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
     }
-    addMany(dto) {
-        return this.httpClient.post(`${this.basePath}/many`, dto);
+    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 = {}) {
+    getMany(params = {}, options = {}) {
         params.limit = params.limit || 0;
         params.page = params.page || 1;
-        return this.httpClient.get(`${this.basePath}`, { params });
+        return this.httpClient.get(`${this.basePath}`, Object.assign({ params }, options));
     }
-    getManyFiltered(filter, params = {}) {
+    getManyFiltered(filter, params = {}, options = {}) {
         params.filter = this.getFilterString(filter);
-        return this.getMany(params);
+        return this.getMany(params, options);
     }
-    updateOne(id, dto) {
-        return this.httpClient.put(`${this.basePath}/${id}`, dto);
+    updateOne(id, dto, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}`, dto, options);
     }
-    deleteOne(id, force = false) {
-        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force } });
+    deleteOne(id, force = false, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}`, Object.assign({ params: { force } }, options));
     }
     getFilterString(filter) {
         const filters = [];

package/dist/endpoint.service.d.ts

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

package/dist/endpoint.service.js

@@ -6,11 +6,11 @@ class EndpointService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/notification/endpoints');
     }
-    sendNotification(endpointId, payload) {
-        return this.httpClient.post(`${this.basePath}/${endpointId}`, payload);
+    sendNotification(endpointId, payload, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${endpointId}`, payload, options);
     }
-    readLastLogByGroup(endpointId, group) {
-        return this.httpClient.get(`${this.basePath}/${endpointId}/logs/${group}/last`);
+    readLastLogByGroup(endpointId, group, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${endpointId}/logs/${group}/last`, options);
     }
 }
 exports.EndpointService = EndpointService;

package/dist/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/dist/events.service.js

@@ -6,8 +6,8 @@ class EventsService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/events');
     }
-    getLastEventByAssetAndGroup(assetId, group) {
-        return this.httpClient.get(`${this.basePath}/last/${assetId}/${group}`);
+    getLastEventByAssetAndGroup(assetId, group, options = {}) {
+        return this.httpClient.get(`${this.basePath}/last/${assetId}/${group}`, options);
     }
 }
 exports.EventsService = EventsService;

package/dist/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 {};

package/dist/flow-deployment.service.js

@@ -15,36 +15,36 @@ class FlowDeploymentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/deployments');
     }
-    addMany(dto) {
-        const reqs = dto.map((v) => this.addOne(v));
+    addMany(dto, options = {}) {
+        const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
     }
-    updateOne(id, dto, force = false) {
-        return this.httpClient.put(`${this.basePath}/${id}`, dto, { params: { force } });
+    updateOne(id, dto, options = { force: false }) {
+        return super.updateOne(id, dto, options);
     }
-    getDeploymentStatistics(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/statistics`);
+    getDeploymentStatistics(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/statistics`, options);
     }
-    getDeploymentMetrics(id, range = '12h', interval = '5m') {
+    getDeploymentMetrics(id, range = '12h', interval = '5m', options = {}) {
         const params = { range, interval };
-        return this.httpClient.get(`${this.basePath}/${id}/metrics`, { params });
+        return this.httpClient.get(`${this.basePath}/${id}/metrics`, Object.assign({ params }, options));
     }
-    getDeploymentLogs(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/logs`);
+    getDeploymentLogs(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/logs`, options);
     }
-    resolveReferences(id, recursive = true, types) {
+    resolveReferences(id, recursive = true, types, options = {}) {
         var _a;
         const params = { recursive, types: (_a = types === null || types === void 0 ? void 0 : types.join(',')) !== null && _a !== void 0 ? _a : undefined };
-        return this.httpClient.get(`${this.basePath}/${id}/references`, { params });
+        return this.httpClient.get(`${this.basePath}/${id}/references`, Object.assign({ params }, options));
     }
-    updateStatus(id, desiredStatus) {
-        return this.httpClient.put(`${this.basePath}/${id}/status`, { desiredStatus });
+    updateStatus(id, desiredStatus, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/status`, { desiredStatus }, options);
     }
-    deleteOne(id) {
-        return this.updateStatus(id, 'deleted');
+    deleteOne(id, _force, options = {}) {
+        return this.updateStatus(id, 'deleted', options);
     }
-    waitForRunningStatus(id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+    waitForRunningStatus(id_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (id, options = {}) {
             return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const esId = yield this.subscribeToStatus(id, (event) => {
                     if (event.type === 'message' &&
@@ -57,18 +57,18 @@ class FlowDeploymentService extends BaseService {
                             reject(`Deployment in failed status: ${event.data}`);
                         }
                     }
-                });
+                }, (event) => reject(event), options);
             }));
         });
     }
-    addOne(dto) {
-        return super.addOne(dto);
+    addOne(dto, options = {}) {
+        return super.addOne(dto, options);
     }
-    subscribeToStatus(id, listener, errorListener) {
-        return this.httpClient.addEventSource(`${this.basePath}/${id}/status`, listener, errorListener);
+    subscribeToStatus(id, listener, errorListener, options = {}) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/status`, listener, errorListener, options);
     }
-    subscribeToLogs(id, listener, errorListener) {
-        return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener);
+    subscribeToLogs(id, listener, errorListener, options = {}) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener, options);
     }
 }
 exports.FlowDeploymentService = FlowDeploymentService;

package/dist/flow-function.service.d.ts

@@ -1,11 +1,11 @@
 import { DataService } from './data.service';
 import { FlowFunctionDto } from './flow-function.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { Paginated } from './data.interface';
 export declare class FlowFunctionService extends DataService<FlowFunctionDto> {
     constructor(httpClient: HttpClient);
-    addMany(dto: any[]): Promise<FlowFunctionDto[]>;
-    getRevisions(fqn: string): Promise<Paginated<FlowFunctionDto[]>>;
-    rollback(fqn: string, revisionId: string): Promise<FlowFunctionDto>;
-    deleteRevision(fqn: string, revisionId: string): Promise<any>;
+    addMany(dto: any[], options?: TokenOption): Promise<FlowFunctionDto[]>;
+    getRevisions(fqn: string, options?: TokenOption): Promise<Paginated<FlowFunctionDto[]>>;
+    rollback(fqn: string, revisionId: string, options?: TokenOption): Promise<FlowFunctionDto>;
+    deleteRevision(fqn: string, revisionId: string, options?: TokenOption): Promise<any>;
 }

package/dist/flow-function.service.js

@@ -6,18 +6,18 @@ class FlowFunctionService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/functions');
     }
-    addMany(dto) {
-        const reqs = dto.map((v) => this.addOne(v));
+    addMany(dto, options = {}) {
+        const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
     }
-    getRevisions(fqn) {
-        return this.httpClient.get(`${this.basePath}/${fqn}/revisions`);
+    getRevisions(fqn, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${fqn}/revisions`, options);
     }
-    rollback(fqn, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${fqn}/rollback`, { revisionId });
+    rollback(fqn, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback`, { revisionId }, options);
     }
-    deleteRevision(fqn, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`);
+    deleteRevision(fqn, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`, options);
     }
 }
 exports.FlowFunctionService = FlowFunctionService;

package/dist/flow-module.service.d.ts

@@ -1,11 +1,11 @@
 import { DataService } from './data.service';
 import { FlowModule } from './flow-module.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import FormData from 'form-data';
 export declare class FlowModuleService extends DataService<FlowModule> {
     constructor(httpClient: HttpClient);
-    deleteArtifact(name: string, version: string): Promise<FlowModule>;
-    publish(form: FormData): Promise<unknown>;
-    addOne(dto: any): Promise<FlowModule>;
-    addMany(dto: any[]): Promise<FlowModule[]>;
+    deleteArtifact(name: string, version: string, options?: TokenOption): Promise<FlowModule>;
+    publish(form: FormData, options?: TokenOption): Promise<unknown>;
+    addOne(_dto: any): Promise<FlowModule>;
+    addMany(_dto: any[]): Promise<FlowModule[]>;
 }

package/dist/flow-module.service.js

@@ -6,21 +6,17 @@ class FlowModuleService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');
     }
-    deleteArtifact(name, version) {
-        return this.httpClient.delete(`${this.basePath}/${name}/${version}`);
+    deleteArtifact(name, version, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${name}/${version}`, options);
     }
-    publish(form) {
-        const config = {
-            headers: Object.assign({}, form.getHeaders()),
-            maxBodyLength: Infinity,
-            maxContentLength: Infinity,
-        };
+    publish(form, options = {}) {
+        const config = Object.assign({ headers: Object.assign({}, form.getHeaders()), maxBodyLength: Infinity, maxContentLength: Infinity }, options);
         return this.httpClient.post(`${this.basePath}`, form, config);
     }
-    addOne(dto) {
+    addOne(_dto) {
         throw new Error('not allowed: use publish instead');
     }
-    addMany(dto) {
+    addMany(_dto) {
         throw new Error('not allowed: use publish instead');
     }
 }

package/dist/flow.service.d.ts

@@ -3,7 +3,7 @@ import { Paginated, RequestParameter } from './data.interface';
 import { DataService } from './data.service';
 import { FlowDiagram, FlowDto } from './flow.interface';
 import { FlowDeployment } from './flow-deployment.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<FlowDto>, TrashService<FlowDto> {
 }
@@ -11,14 +11,16 @@ declare class BaseService extends APIBase {
 }
 export declare class FlowService extends BaseService {
     constructor(httpClient: HttpClient);
-    addMany(dto: any[]): Promise<FlowDto[]>;
-    getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
-    getOne(id: string, options?: any): Promise<FlowDto>;
-    getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
-    getDiagramRevisions(id: string): Promise<FlowDiagram[]>;
-    isDeploymentOnLatestDiagramVersion(depl: FlowDeployment): Promise<boolean>;
-    getRevisions(id: string): Promise<Paginated<FlowDto[]>>;
-    rollback(id: string, revisionId: string): Promise<FlowDto>;
-    deleteRevision(id: string, revisionId: string): Promise<any>;
+    addMany(dto: any[], options?: TokenOption): Promise<FlowDto[]>;
+    getMany(params?: RequestParameter, options?: TokenOption): Promise<Paginated<FlowDto[]>>;
+    getOne(id: string, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<FlowDto>;
+    getFlowWithDiagram(diagramId: string, options?: TokenOption): Promise<FlowDto>;
+    getDiagramRevisions(id: string, options?: TokenOption): Promise<FlowDiagram[]>;
+    isDeploymentOnLatestDiagramVersion(depl: FlowDeployment, options?: TokenOption): Promise<boolean>;
+    getRevisions(id: string, options?: TokenOption): Promise<Paginated<FlowDto[]>>;
+    rollback(id: string, revisionId: string, options?: TokenOption): Promise<FlowDto>;
+    deleteRevision(id: string, revisionId: string, options?: TokenOption): Promise<any>;
 }
 export {};

package/dist/flow.service.js

@@ -15,40 +15,40 @@ class FlowService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flows');
     }
-    addMany(dto) {
-        const reqs = dto.map((v) => this.addOne(v));
+    addMany(dto, options = {}) {
+        const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
     }
-    getMany(params = {}) {
+    getMany(params = {}, options = {}) {
         params.populate = params.populate ? params.populate : 'none';
-        return super.getMany(params);
+        return super.getMany(params, options);
     }
     getOne(id, options = {}) {
         options.populate = options.populate ? options.populate : 'none';
         return super.getOne(id, options);
     }
-    getFlowWithDiagram(diagramId) {
-        return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`);
+    getFlowWithDiagram(diagramId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`, options);
     }
-    getDiagramRevisions(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/diagram/revisions`);
+    getDiagramRevisions(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/diagram/revisions`, options);
     }
-    isDeploymentOnLatestDiagramVersion(depl) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+    isDeploymentOnLatestDiagramVersion(depl_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (depl, options = {}) {
             const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
             const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
-            const revisions = yield this.getDiagramRevisions(flowId);
+            const revisions = yield this.getDiagramRevisions(flowId, options);
             return revisions[revisions.length - 1].id === diagramId;
         });
     }
-    getRevisions(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/revisions`);
+    getRevisions(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/revisions`, options);
     }
-    rollback(id, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId });
+    rollback(id, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId }, options);
     }
-    deleteRevision(id, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`);
+    deleteRevision(id, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`, options);
     }
 }
 exports.FlowService = FlowService;

package/dist/http.service.d.ts

@@ -2,6 +2,10 @@ import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
 import EventSource from 'eventsource';
 import { Queue } from './Queue';
 import { TokenSet } from './token-set';
+export type TokenOption = {
+    token?: string;
+};
+export type Config = TokenOption & AxiosRequestConfig;
 export declare class HttpClient {
     protected readonly baseURL: string;
     protected readonly authBaseURL: string;
@@ -14,6 +18,7 @@ export declare class HttpClient {
     protected readonly requestQueue: Queue;
     private tokenSet;
     private exchangedTokenSet;
+    private discoveredIssuers;
     eventSourcesMap: Map<string, {
         eventSource: EventSource;
         listener: (event: MessageEvent) => void;
@@ -26,12 +31,12 @@ export declare class HttpClient {
         size: number;
         total: number;
     };
-    delete: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
-    get: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
-    post: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
-    put: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
-    protected request: <T>(method: Method, url: string, config?: AxiosRequestConfig, data?: any) => Promise<T>;
-    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    delete: <T>(url: string, config?: Config) => Promise<T>;
+    get: <T>(url: string, config?: Config) => Promise<T>;
+    post: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    put: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    protected request: <T>(method: Method, url: string, config?: Config, data?: any) => Promise<T>;
+    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
     destroyEventSource(id: string): void;
     destroyAllEventSources(): void;
     getAccessToken: (forceRefresh?: boolean) => Promise<string>;
@@ -39,6 +44,7 @@ export declare class HttpClient {
     protected discoverIssuer(uri: string): Promise<Issuer>;
     protected requestAccessToken(additionalOpts?: {}): Promise<TokenSet>;
     protected exchangeAccessToken(accessToken: string): Promise<TokenSet>;
+    provideExternalToken(token: string): Promise<void>;
 }
 interface Issuer {
     issuer: string;

package/dist/http.service.js

@@ -17,6 +17,7 @@ class HttpClient {
         this.clientId = clientId;
         this.clientSecret = clientSecret;
         this.tokenSubject = tokenSubject;
+        this.discoveredIssuers = new Map();
         this.eventSourcesMap = new Map();
         this.getQueueStats = () => { var _a; return (_a = this.requestQueue) === null || _a === void 0 ? void 0 : _a.getStats(); };
         this.delete = (url, config) => this.request('DELETE', url, config);
@@ -25,7 +26,8 @@ class HttpClient {
         this.put = (url, data, config) => this.request('PUT', url, config, data);
         this.request = (method, url, config = {}, data) => {
             return this.requestQueue.add(() => new Promise((resolve, reject) => {
-                this.getAccessToken()
+                const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();
+                tokenP
                     .then((token) => {
                     const headers = Object.assign({ Authorization: `Bearer ${token}` }, config.headers);
                     return this.axiosInstance.request(Object.assign(Object.assign({}, config), { headers, method, url, data }));
@@ -35,8 +37,12 @@ class HttpClient {
             }));
         };
         this.getAccessToken = (...args_1) => tslib_1.__awaiter(this, [...args_1], void 0, function* (forceRefresh = false) {
+            var _a;
             let accessToken;
             if (forceRefresh || !this.tokenSet || this.tokenSet.isExpired()) {
+                if ((_a = this.tokenSet) === null || _a === void 0 ? void 0 : _a.provided) {
+                    throw new Error('provided token is expired and cannot be refreshed, provide a new token.');
+                }
                 this.tokenSet = yield this.requestAccessToken();
                 accessToken = this.tokenSet.accessToken;
             }
@@ -57,8 +63,8 @@ class HttpClient {
         this.authAxiosInstance = axios_1.default.create({ baseURL: authBaseURL || baseURL, timeout: 10000 });
         this.requestQueue = new Queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
     }
-    addEventSource(url, listener, errorListener) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+    addEventSource(url_1, listener_1, errorListener_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (url, listener, errorListener, options = {}) {
             const id = (0, uuid_1.v4)();
             const errListener = errorListener
                 ? errorListener
@@ -66,7 +72,7 @@ class HttpClient {
                     throw new Error(JSON.stringify(event, null, 2));
                 };
             const es = new eventsource_1.default(`${this.baseURL}${url}`, {
-                headers: { authorization: 'Bearer ' + (yield this.getAccessToken()) },
+                headers: { authorization: 'Bearer ' + options.token ? options.token : yield this.getAccessToken() },
             });
             es.addEventListener('message', listener);
             es.addEventListener('error', errListener);
@@ -100,12 +106,17 @@ class HttpClient {
     }
     discoverIssuer(uri) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.discoveredIssuers.has(uri)) {
+                return this.discoveredIssuers.get(uri);
+            }
             const wellKnownUri = `${uri}/.well-known/openid-configuration`;
             const issuerResponse = yield this.authAxiosInstance.get(wellKnownUri, {
                 responseType: 'json',
                 headers: { Accept: 'application/json' },
             });
-            return this.validateIssuer(issuerResponse.data);
+            const validIssuer = this.validateIssuer(issuerResponse.data);
+            this.discoveredIssuers.set(uri, validIssuer);
+            return validIssuer;
         });
     }
     requestAccessToken() {
@@ -157,5 +168,15 @@ class HttpClient {
             return this.requestAccessToken(opts);
         });
     }
+    provideExternalToken(token) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const issuer = yield this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
+            const { iss: providedIssuer, exp } = (0, jose_1.decodeJwt)(token);
+            if (issuer.issuer !== providedIssuer) {
+                throw new Error(`Provided token is not issued by currently configured issuer. Provided token issued by ${providedIssuer}, but ${issuer.issuer} is configured.`);
+            }
+            this.tokenSet = new token_set_1.TokenSet(token, exp - Date.now() / 1000, true);
+        });
+    }
 }
 exports.HttpClient = HttpClient;

package/dist/label.service.d.ts

@@ -1,9 +1,9 @@
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { Label } from './label.interface';
 export declare class LabelService extends DataService<Label> {
     constructor(httpClient: HttpClient);
-    addMany(dtos: Label[]): Promise<Label[]>;
-    getOneByName(name: string): Promise<Label>;
-    count(): Promise<number>;
+    addMany(dtos: Label[], options?: TokenOption): Promise<Label[]>;
+    getOneByName(name: string, options?: TokenOption): Promise<Label>;
+    count(options?: TokenOption): Promise<number>;
 }

package/dist/label.service.js

@@ -6,14 +6,14 @@ class LabelService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/labels');
     }
-    addMany(dtos) {
-        return Promise.all(dtos.map((dto) => this.addOne(dto)));
+    addMany(dtos, options = {}) {
+        return Promise.all(dtos.map((dto) => this.addOne(dto, options)));
     }
-    getOneByName(name) {
-        return this.httpClient.get(`${this.basePath}/name/${name}`);
+    getOneByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}/name/${name}`, options);
     }
-    count() {
-        return this.httpClient.get(`${this.basePath}/count`);
+    count(options = {}) {
+        return this.httpClient.get(`${this.basePath}/count`, options);
     }
 }
 exports.LabelService = LabelService;

package/dist/proxy.service.d.ts

@@ -1,11 +1,11 @@
 import { AxiosRequestConfig } from 'axios';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 export declare class ProxyService {
     private readonly httpClient;
     constructor(httpClient: HttpClient);
-    delete: <T>(proxyId: string, path: string, config?: AxiosRequestConfig) => Promise<T>;
-    get: <T>(proxyId: string, path: string, config?: AxiosRequestConfig) => Promise<T>;
-    post: <T>(proxyId: string, path: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
-    put: <T>(proxyId: string, path: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
+    delete: <T>(proxyId: string, path: string, config?: TokenOption & AxiosRequestConfig) => Promise<T>;
+    get: <T>(proxyId: string, path: string, config?: TokenOption & AxiosRequestConfig) => Promise<T>;
+    post: <T>(proxyId: string, path: string, data: any, config?: TokenOption & AxiosRequestConfig) => Promise<T>;
+    put: <T>(proxyId: string, path: string, data: any, config?: TokenOption & AxiosRequestConfig) => Promise<T>;
     private url;
 }

package/dist/task.service.d.ts

@@ -1,6 +1,6 @@
 import { APIBase } from './api-base';
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { Task } from './task.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<Task>, TrashService<Task> {
@@ -9,6 +9,6 @@ declare class BaseService extends APIBase {
 }
 export declare class TaskService extends BaseService {
     constructor(httpClient: HttpClient);
-    createTaskAttachedToAsset(dto: any): Promise<Task>;
+    createTaskAttachedToAsset(dto: any, options?: TokenOption): Promise<Task>;
 }
 export {};

package/dist/task.service.js

@@ -15,8 +15,8 @@ class TaskService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/tasks');
     }
-    createTaskAttachedToAsset(dto) {
-        return this.httpClient.post(this.basePath, dto);
+    createTaskAttachedToAsset(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
     }
 }
 exports.TaskService = TaskService;

package/dist/timeseries.service.d.ts

@@ -1,7 +1,7 @@
 import { APIBase } from './api-base';
 import { Paginated } from './data.interface';
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { TimeSeries, TimeSeriesValue, TS_GROUPS } from './timeseries.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<TimeSeries>, TrashService<TimeSeries> {
@@ -12,7 +12,7 @@ export declare class TimeSeriesService extends BaseService {
     constructor(httpClient: HttpClient);
     addValue(id: string, value: {
         [timestamp: string]: any;
-    }): Promise<void>;
+    }, options?: TokenOption): Promise<void>;
     /**
      * Adds time series values to an asset by the name of the time series.
      * If the time series does not exist, it is created.
@@ -25,11 +25,12 @@ export declare class TimeSeriesService extends BaseService {
      *   [timestamp: string]: any, // The timestamp and value pairs
      *   ...
      * }
+     * @param options
      * @returns a promise that resolves to the time series that was added.
      */
     addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
         [timestamp: string]: any;
-    }): Promise<TimeSeries>;
+    }, options?: TokenOption): Promise<TimeSeries>;
     /**
      * Adds multiple time series values to an asset by the name of the time series.
      * If the time series does not exist, it is created.
@@ -46,6 +47,7 @@ export declare class TimeSeriesService extends BaseService {
      *  },
      *  ...
      * }
+     * @param options
      * @returns a promise that resolves to an array of objects containing the results of the operation.
      * Each object has the following structure:
      * {
@@ -58,10 +60,10 @@ export declare class TimeSeriesService extends BaseService {
         [timeSeriesName: string]: {
             [timestamp: string]: any;
         };
-    }): Promise<PromiseSettledResult<TimeSeries>[]>;
-    getMostRecentValue(id: string, before?: Date): Promise<TimeSeriesValue>;
-    getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
-    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
-    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries[]>>;
+    }, options?: TokenOption): Promise<PromiseSettledResult<TimeSeries>[]>;
+    getMostRecentValue(id: string, before?: Date, options?: TokenOption): Promise<TimeSeriesValue>;
+    getValues(id: string, from: number, limit?: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
+    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
+    getManyByAsset(assetId: string, names?: string[], options?: TokenOption): Promise<Paginated<TimeSeries[]>>;
 }
 export {};

package/dist/timeseries.service.js

@@ -15,42 +15,42 @@ class TimeSeriesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/tsm');
     }
-    addValue(id, value) {
-        return this.httpClient.post(`${this.basePath}/${id}`, value);
+    addValue(id, value, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${id}`, value, options);
     }
-    addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values) {
+    addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values, options = {}) {
         const dto = {
             name,
             readPermissions,
             readWritePermissions,
             values,
         };
-        return this.httpClient.post(`${this.basePath}/assets/${assetId}`, dto);
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}`, dto, options);
     }
-    addManyAssetTimeSeriesValues(assetId, readPermissions, readWritePermissions, timeSeries) {
+    addManyAssetTimeSeriesValues(assetId, readPermissions, readWritePermissions, timeSeries, options = {}) {
         const dtos = Object.entries(timeSeries).map(([name, values]) => ({
             name,
             readPermissions,
             readWritePermissions,
             values,
         }));
-        return this.httpClient.post(`${this.basePath}/assets/${assetId}/bulk`, dtos);
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}/bulk`, dtos, options);
     }
-    getMostRecentValue(id, before) {
+    getMostRecentValue(id, before, options = {}) {
         const params = before ? { before: before.toISOString() } : {};
-        return this.httpClient.get(`${this.basePath}/${id}/recent`, { params });
+        return this.httpClient.get(`${this.basePath}/${id}/recent`, Object.assign({ params }, options));
     }
-    getValues(id, from, limit, group) {
+    getValues(id, from, limit, group, options = {}) {
         const params = { limit, group };
-        return this.httpClient.get(`${this.basePath}/${id}/${from}`, { params });
+        return this.httpClient.get(`${this.basePath}/${id}/${from}`, Object.assign({ params }, options));
     }
-    getValuesOfPeriod(id, from, to, group) {
+    getValuesOfPeriod(id, from, to, group, options = {}) {
         const params = { group };
-        return this.httpClient.get(`${this.basePath}/${id}/${from}/${to}`, { params });
+        return this.httpClient.get(`${this.basePath}/${id}/${from}/${to}`, Object.assign({ params }, options));
     }
-    getManyByAsset(assetId, names) {
+    getManyByAsset(assetId, names, options = {}) {
         const params = Array.isArray(names) ? { names: names.join() } : {};
-        return this.httpClient.get(`${this.basePath}/asset/${assetId}`, { params });
+        return this.httpClient.get(`${this.basePath}/asset/${assetId}`, Object.assign({ params }, options));
     }
 }
 exports.TimeSeriesService = TimeSeriesService;

package/dist/token-set.d.ts

@@ -1,9 +1,11 @@
 export declare class TokenSet {
     private readonly _accessToken;
     private readonly _expiresAt;
-    constructor(access_token: string, expires_in: number);
+    private readonly _provided;
+    constructor(access_token: string, expires_in: number, provided?: boolean);
     get accessToken(): string;
     get expiresAt(): number;
     get expiresIn(): number;
+    get provided(): boolean;
     isExpired(): boolean;
 }

package/dist/token-set.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenSet = void 0;
 const TOKEN_EXPIRATION_BUFFER = 20;
 class TokenSet {
-    constructor(access_token, expires_in) {
+    constructor(access_token, expires_in, provided = false) {
         this._accessToken = access_token;
         this._expiresAt = Math.floor(Date.now() / 1000) + Number(expires_in);
+        this._provided = provided;
     }
     get accessToken() {
         return this._accessToken;
@@ -16,8 +17,11 @@ class TokenSet {
     get expiresIn() {
         return Math.max(this.expiresAt - Math.ceil(Date.now() / 1000), 0);
     }
+    get provided() {
+        return this._provided;
+    }
     isExpired() {
-        return this.expiresIn <= TOKEN_EXPIRATION_BUFFER;
+        return this.expiresIn <= (this.provided ? 0 : TOKEN_EXPIRATION_BUFFER);
     }
 }
 exports.TokenSet = TokenSet;

package/dist/user.service.d.ts

@@ -1,11 +1,11 @@
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { UserSettings } from './user-settings.interface';
 export declare class UserService {
     private httpClient;
     private readonly basePath;
     constructor(httpClient: HttpClient);
     getCurrentUserRoles(): Promise<string[]>;
-    getUserSettings(): Promise<UserSettings>;
-    updateUserSettings(settings: UserSettings): Promise<UserSettings>;
-    deleteUserSettings(): Promise<UserSettings>;
+    getUserSettings(options?: TokenOption): Promise<UserSettings>;
+    updateUserSettings(settings: UserSettings, options?: TokenOption): Promise<UserSettings>;
+    deleteUserSettings(options?: TokenOption): Promise<UserSettings>;
 }

package/dist/user.service.js

@@ -20,14 +20,14 @@ class UserService {
             }
         });
     }
-    getUserSettings() {
-        return this.httpClient.get(this.basePath);
+    getUserSettings(options = {}) {
+        return this.httpClient.get(this.basePath, options);
     }
-    updateUserSettings(settings) {
-        return this.httpClient.put(this.basePath, settings);
+    updateUserSettings(settings, options = {}) {
+        return this.httpClient.put(this.basePath, settings, options);
     }
-    deleteUserSettings() {
-        return this.httpClient.delete(this.basePath);
+    deleteUserSettings(options = {}) {
+        return this.httpClient.delete(this.basePath, options);
     }
 }
 exports.UserService = UserService;

package/dist/vault.service.d.ts

@@ -1,7 +1,7 @@
 import { DataService } from './data.service';
 import { VaultSecret } from './vault.interface';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 export declare class VaultService extends DataService<VaultSecret> {
     constructor(httpClient: HttpClient);
-    getSecret(name: string, version?: number): Promise<string>;
+    getSecret(name: string, version?: number, options?: TokenOption): Promise<string>;
 }

package/dist/vault.service.js

@@ -6,9 +6,9 @@ class VaultService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/vault/secrets');
     }
-    getSecret(name, version) {
+    getSecret(name, version, options = {}) {
         const params = version ? { version } : {};
-        return this.httpClient.get(`${this.basePath}/${name}/secret`, { params });
+        return this.httpClient.get(`${this.basePath}/${name}/secret`, Object.assign({ params }, options));
     }
 }
 exports.VaultService = VaultService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "5.3.4",
+  "version": "6.0.0",
   "description": "Module for easy access to the HahnPRO API",
   "license": "MIT",
   "author": {