@hahnpro/hpc-api 2025.12.0 → 2026.1.0

package/src/lib/mock/notification-rules.mock.service.d.ts

@@ -1,5 +1,12 @@
 import { NotificationRule } from '../interfaces';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
 import { ShareMockService } from './share.mock.service';
-export declare class NotificationRulesMockService extends ShareMockService<NotificationRule> {
+interface BaseService extends DataMockService<NotificationRule>, ShareMockService<NotificationRule> {
+}
+declare class BaseService extends APIBaseMock<NotificationRule> {
+}
+export declare class NotificationRulesMockService extends BaseService {
     constructor(notificationRules: NotificationRule[]);
 }
+export {};

package/src/lib/mock/notification-rules.mock.service.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationRulesMockService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
+const data_mock_service_1 = require("./data.mock.service");
 const share_mock_service_1 = require("./share.mock.service");
-class NotificationRulesMockService extends share_mock_service_1.ShareMockService {
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, share_mock_service_1.ShareMockService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class NotificationRulesMockService extends BaseService {
     constructor(notificationRules) {
         super();
         this.data = notificationRules;

package/src/lib/mock/organizations-administration.mock.service.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { APIBaseMock, OrganizationsMockService } from '.';
-import { Filter, Organization, OrganizationCreateDto, OrganizationMembersInviteOrAdd, OrganizationResourcesProgress, OrganizationSearchQuery, Paginated, RequestParameter, ServerSentEvent, SubscriptionType, UserWithOrgRoles } from '../interfaces';
+import { Filter, Organization, OrganizationCreateDto, OrganizationResourcesProgress, OrganizationSearchQuery, Paginated, RequestParameter, ServerSentEvent, SubscriptionType, UserWithOrgRoles } from '../interfaces';
 import { OrganizationsAdministrationService } from '../services';
 export declare class OrganizationsAdministrationMockService extends APIBaseMock<Organization> implements OrganizationsAdministrationService {
     private readonly organizationMockService;
@@ -14,6 +14,6 @@ export declare class OrganizationsAdministrationMockService extends APIBaseMock<
     getMany(params?: RequestParameter): Promise<Paginated<Organization>>;
     getManyFiltered(filter: Filter, params?: RequestParameter): Promise<Paginated<Organization>>;
     search(query: OrganizationSearchQuery): Promise<Organization[]>;
-    createOrganization(organizationCreateDto: OrganizationCreateDto, userEmail: string, inviteOrAdd: OrganizationMembersInviteOrAdd, createOrgAsOwner?: boolean): Promise<Organization>;
+    createOrganization(organizationCreateDto: OrganizationCreateDto, emailsToInvite: string[], emailsToAdd: string[], createOrgAsOwner?: boolean): Promise<Organization>;
     getOrganizationDeletionProgress(organizationId: string): Observable<ServerSentEvent<OrganizationResourcesProgress>>;
 }

package/src/lib/mock/organizations-administration.mock.service.js

@@ -76,9 +76,9 @@ class OrganizationsAdministrationMockService extends _1.APIBaseMock {
     async search(query) {
         return Promise.resolve(this.data.filter((entry) => entry.name === query.name || entry.name.startsWith(query.name)));
     }
-    createOrganization(organizationCreateDto, userEmail, inviteOrAdd, createOrgAsOwner = false) {
+    createOrganization(organizationCreateDto, emailsToInvite, emailsToAdd, createOrgAsOwner = false) {
         if (!organizationCreateDto?.name ||
-            !userEmail ||
+            ([...emailsToInvite, ...emailsToAdd].length === 0 && !createOrgAsOwner) ||
             this.data.some((org) => org.name === organizationCreateDto.name)) {
             return Promise.reject('Bad Request');
         }

package/src/lib/mock/share.mock.service.d.ts

@@ -1,7 +1,7 @@
-import { DataMockService } from '.';
+import { APIBaseMock } from '.';
 import { OrgResourcePermission, SharedResources } from '../interfaces/resource.interface';
 import { ShareService } from '../services/share.service';
-export declare class ShareMockService<T> extends DataMockService<T> implements ShareService<T> {
+export declare class ShareMockService<T> extends APIBaseMock<T> implements ShareService {
     constructor();
     getBasePath(): string;
     cancelAccess(id: string): Promise<void>;

package/src/lib/mock/share.mock.service.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShareMockService = void 0;
 const _1 = require(".");
-class ShareMockService extends _1.DataMockService {
+class ShareMockService extends _1.APIBaseMock {
     constructor() {
         super();
     }

package/src/lib/mock/task.mock.service.d.ts

@@ -1,8 +1,8 @@
-import { APIBaseMock, TrashMockService } from '.';
+import { APIBaseMock, DataMockService, TrashMockService } from '.';
 import { DeleteQuery, LogbookEntry, LogbookEntryDto, Paginated, RequestParameter, Task, TokenOption } from '../interfaces';
 import { TaskService } from '../services';
 import { ShareMockService } from './share.mock.service';
-interface BaseService extends ShareMockService<Task>, TrashMockService<Task> {
+interface BaseService extends DataMockService<Task>, ShareMockService<Task>, TrashMockService<Task> {
 }
 declare class BaseService extends APIBaseMock<Task> {
 }

package/src/lib/mock/task.mock.service.js

@@ -8,8 +8,9 @@ const share_mock_service_1 = require("./share.mock.service");
 let BaseService = class BaseService extends _1.APIBaseMock {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_mock_service_1.ShareMockService, _1.TrashMockService)
+    (0, ts_mixer_1.mix)(_1.DataMockService, share_mock_service_1.ShareMockService, _1.TrashMockService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class TaskMockService extends BaseService {
     constructor(tasks, logbookEntries = []) {
         super(tasks);
@@ -72,7 +73,7 @@ class TaskMockService extends BaseService {
         const entry = {
             id,
             taskId,
-            date: dto.date || new Date(),
+            date: dto.date || now,
             duration: dto.duration ?? 0,
             materials: dto.materials || [],
             comment: dto.comment || '',

package/src/lib/mock/timeseries.mock.service.d.ts

@@ -1,8 +1,10 @@
-import { APIBaseMock, TrashMockService } from '.';
+import { APIBaseMock, DataMockService, TrashMockService } from '.';
 import { DeleteQuery, Paginated, RequestParameter, TimeSeries, TimeSeriesValue, TS_GROUPS } from '../interfaces';
 import { TimeSeriesService } from '../services';
 import { ShareMockService } from './share.mock.service';
-interface BaseService extends ShareMockService<TimeSeries & {
+interface BaseService extends DataMockService<TimeSeries & {
+    data: TimeSeriesValue[];
+}>, ShareMockService<TimeSeries & {
     data: TimeSeriesValue[];
 }>, TrashMockService<TimeSeries & {
     data: TimeSeriesValue[];

package/src/lib/mock/timeseries.mock.service.js

@@ -8,7 +8,7 @@ const share_mock_service_1 = require("./share.mock.service");
 let BaseService = class BaseService extends _1.APIBaseMock {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_mock_service_1.ShareMockService, _1.TrashMockService)
+    (0, ts_mixer_1.mix)(_1.DataMockService, share_mock_service_1.ShareMockService, _1.TrashMockService)
 ], BaseService);
 class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {

package/src/lib/mock/trash.mock.service.d.ts

@@ -3,6 +3,7 @@ import { Paginated, RequestParameter } from '../interfaces';
 import { TrashService } from '../services';
 export declare class TrashMockService<T extends {
     id?: string;
+    fqn?: string;
 }> extends APIBaseMock<T> implements TrashService<T> {
     constructor();
     trashRestoreAll(): Promise<T[]>;

package/src/lib/mock/trash.mock.service.js

@@ -14,15 +14,15 @@ class TrashMockService extends _1.APIBaseMock {
         return Promise.resolve(deleted);
     }
     trashRestoreOne(id) {
-        const deleted = this.data.find((v) => v['id'] === id);
+        const deleted = this.data.find((v) => (v['id'] ? v['id'] === id : v['fqn'] === id));
         delete deleted['deletedAt'];
         return Promise.resolve(deleted);
     }
     async emptyTrash(offset) {
         const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
         const date = new Date(dateOffsSeconds * 1000);
-        const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
-        this.data = this.data.filter((item) => !trashIds.includes(item.id));
+        const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => (v.id ? v.id : v.fqn));
+        this.data = this.data.filter((item) => !trashIds.includes(item.id ? item.id : item.fqn));
         return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
     }
     getTrash(params) {

package/src/lib/services/alert.service.d.ts

@@ -1,6 +1,13 @@
+import { APIBase } from '../api-base';
 import { Alert } from '../interfaces';
+import { DataService } from './data.service';
 import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-export declare class AlertService extends ShareService<Alert> {
+interface BaseService extends DataService<Alert>, ShareService {
+}
+declare class BaseService extends APIBase {
+}
+export declare class AlertService extends BaseService {
     constructor(httpClient: HttpClientService);
 }
+export {};

package/src/lib/services/alert.service.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlertService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_1 = require("../api-base");
+const data_service_1 = require("./data.service");
 const share_service_1 = require("./share.service");
-class AlertService extends share_service_1.ShareService {
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, share_service_1.ShareService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class AlertService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/alerts');
     }

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

@@ -1,9 +1,9 @@
-import { HttpClientService, TrashService } from '.';
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
 import { AddToProperty, Asset, AssetRevision, Attachment, DeleteAssetQuery, EventCause, EventLevelOverride, Filter, Paginated, RemoveFromProperty, RequestParameter, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
 import { ShareService } from './share.service';
-interface BaseService extends ShareService<Asset>, TrashService<Asset> {
+interface BaseService extends DataService<Asset>, ShareService, TrashService<Asset> {
 }
 declare class BaseService extends APIBase {
 }

package/src/lib/services/asset.service.js

@@ -10,8 +10,9 @@ const share_service_1 = require("./share.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_service_1.ShareService, _1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService, _1.TrashService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class AssetService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assets');

package/src/lib/services/assettypes.service.d.ts

@@ -1,9 +1,10 @@
 import { APIBase } from '../api-base';
 import { AssetType, DeleteAssetTypeQuery, Paginated, Template, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
 import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
 import { TrashService } from './trash.service';
-interface BaseService extends ShareService<AssetType>, TrashService<AssetType> {
+interface BaseService extends DataService<AssetType>, ShareService, TrashService<AssetType> {
 }
 declare class BaseService extends APIBase {
 }

package/src/lib/services/assettypes.service.js

@@ -4,13 +4,15 @@ exports.AssetTypesService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("../api-base");
+const data_service_1 = require("./data.service");
 const share_service_1 = require("./share.service");
 const trash_service_1 = require("./trash.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_service_1.ShareService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(data_service_1.DataService, share_service_1.ShareService, trash_service_1.TrashService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class AssetTypesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assettypes');

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

@@ -1,9 +1,9 @@
-import { HttpClientService, TrashService } from '.';
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
 import { Config, Content, ReturnType, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
 import { ShareService } from './share.service';
-interface BaseService extends ShareService<Content>, TrashService<Content> {
+interface BaseService extends DataService<Content>, ShareService, TrashService<Content> {
 }
 declare class BaseService extends APIBase {
 }

package/src/lib/services/content.service.js

@@ -11,8 +11,9 @@ const share_service_1 = require("./share.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_service_1.ShareService, _1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService, _1.TrashService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class ContentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/contents');

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

@@ -1,8 +1,14 @@
-import { HttpClientService } from '.';
+import { DataService, HttpClientService } from '.';
+import { APIBase } from '../api-base';
 import { Endpoint, EndpointLog, NotificationPayload, TokenOption } from '../interfaces';
 import { ShareService } from './share.service';
-export declare class EndpointService extends ShareService<Endpoint> {
+interface BaseService extends DataService<Endpoint>, ShareService {
+}
+declare class BaseService extends APIBase {
+}
+export declare class EndpointService extends BaseService {
     constructor(httpClient: HttpClientService);
     sendNotification(endpointId: string, payload: NotificationPayload, options?: TokenOption): Promise<void>;
     readLastLogByGroup(endpointId: string, group: string, options?: TokenOption): Promise<EndpointLog>;
 }
+export {};

package/src/lib/services/endpoint.service.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 const share_service_1 = require("./share.service");
-class EndpointService extends share_service_1.ShareService {
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class EndpointService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/notification/endpoints');
     }

package/src/lib/services/event.service.d.ts

@@ -1,8 +1,14 @@
-import { HttpClientService } from '.';
+import { DataService, HttpClientService } from '.';
+import { APIBase } from '../api-base';
 import { Event, TokenOption } from '../interfaces';
 import { ShareService } from './share.service';
-export declare class EventService extends ShareService<Event> {
+interface BaseService extends DataService<Event>, ShareService {
+}
+declare class BaseService extends APIBase {
+}
+export declare class EventService extends BaseService {
     constructor(httpClient: HttpClientService);
     getLastEventByAssetAndGroup(assetId: string, group: string, options?: TokenOption): Promise<Event>;
     getLastEventByAssetAndGroups(assetId: string, groups: string[], options?: TokenOption): Promise<Record<string, string>>;
 }
+export {};

package/src/lib/services/event.service.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 const share_service_1 = require("./share.service");
-class EventService extends share_service_1.ShareService {
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class EventService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/events');
     }

package/src/lib/services/flow-deployment.service.d.ts

@@ -1,8 +1,8 @@
-import { HttpClientService, TrashService } from '.';
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
 import { DeleteQuery, FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog, ResourceReference, TokenOption } from '../interfaces';
 import { ShareService } from './share.service';
-interface BaseService extends ShareService<FlowDeployment>, TrashService<FlowDeployment> {
+interface BaseService extends DataService<FlowDeployment>, ShareService, TrashService<FlowDeployment> {
 }
 declare class BaseService extends APIBase {
 }

package/src/lib/services/flow-deployment.service.js

@@ -9,8 +9,9 @@ const share_service_1 = require("./share.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_service_1.ShareService, _1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService, _1.TrashService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class FlowDeploymentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/deployments');

package/src/lib/services/flow-function.service.d.ts

@@ -1,10 +1,16 @@
-import { HttpClientService } from '.';
+import { DataService, HttpClientService, TrashService } from '.';
+import { APIBase } from '../api-base';
 import { FlowFunctionDto, Paginated, TokenOption } from '../interfaces';
 import { ShareService } from './share.service';
-export declare class FlowFunctionService extends ShareService<FlowFunctionDto> {
+interface BaseService extends DataService<FlowFunctionDto>, ShareService, TrashService<FlowFunctionDto> {
+}
+declare class BaseService extends APIBase {
+}
+export declare class FlowFunctionService extends BaseService {
     constructor(httpClient: HttpClientService);
     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>;
 }
+export {};

package/src/lib/services/flow-function.service.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowFunctionService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 const share_service_1 = require("./share.service");
-class FlowFunctionService extends share_service_1.ShareService {
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService, _1.TrashService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class FlowFunctionService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/functions');
     }

package/src/lib/services/flow-module.service.d.ts

@@ -1,11 +1,17 @@
-import { HttpClientService } from '.';
+import { DataService, HttpClientService } from '.';
+import { APIBase } from '../api-base';
 import { FlowModule, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
 import { ShareService } from './share.service';
-export declare class FlowModuleService extends ShareService<FlowModule> {
+interface BaseService extends DataService<FlowModule>, ShareService {
+}
+declare class BaseService extends APIBase {
+}
+export declare class FlowModuleService extends BaseService {
     constructor(httpClient: HttpClientService);
     deleteArtifact(name: string, version: string, options?: TokenOption): Promise<FlowModule>;
     publish(form: CrossPlatformFormData, options?: TokenOption): Promise<unknown>;
     addOne(_dto: any): Promise<FlowModule>;
     addMany(_dto: any[]): Promise<FlowModule[]>;
 }
+export {};

package/src/lib/services/flow-module.service.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowModuleService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 const utils_1 = require("../utils");
 const share_service_1 = require("./share.service");
-class FlowModuleService extends share_service_1.ShareService {
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService)
+], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class FlowModuleService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');
     }

package/src/lib/services/flow.service.d.ts

@@ -1,8 +1,8 @@
-import { HttpClientService, TrashService } from '.';
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
 import { FlowDeployment, FlowDiagram, FlowDto, Paginated, RequestParameter, TokenOption } from '../interfaces';
 import { ShareService } from './share.service';
-interface BaseService extends ShareService<FlowDto>, TrashService<FlowDto> {
+interface BaseService extends DataService<FlowDto>, ShareService, TrashService<FlowDto> {
 }
 declare class BaseService extends APIBase {
 }

package/src/lib/services/flow.service.js

@@ -9,8 +9,9 @@ const share_service_1 = require("./share.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(share_service_1.ShareService, _1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, share_service_1.ShareService, _1.TrashService)
 ], BaseService);
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
 class FlowService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flows');

package/src/lib/services/http-client.service.d.ts

@@ -1,8 +1,8 @@
-import { AxiosInstance, Method } from 'axios';
+import { AxiosInstance, AxiosResponse, Method } from 'axios';
 import { EventSource } from 'eventsource';
 import { Observable } from 'rxjs';
 import { Config, Issuer, ServerSentEvent, TokenOption } from '../interfaces';
-import { Queue } from '../queue';
+import { Queue, QueueOptions } from '../queue';
 import { TokenSet } from '../token-set';
 export interface HttpClientConfig {
     baseURL: string;
@@ -12,6 +12,7 @@ export interface HttpClientConfig {
     clientSecret?: string;
     tokenSubject?: string;
     activeOrg?: string;
+    queueOptions?: QueueOptions;
 }
 export declare class HttpClientService {
     protected readonly baseURL: string;
@@ -39,6 +40,13 @@ export declare class HttpClientService {
         size: number;
         total: number;
     };
+    /**
+     * Add a response interceptor to the axios instance.
+     * @param onFulfilled Function to handle successful responses
+     * @param onRejected Function to handle response errors
+     * @returns Interceptor ID that can be used to remove the interceptor
+     */
+    addResponseInterceptor(onFulfilled?: ((value: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>) | null, onRejected?: ((error: any) => any) | null): number;
     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>;
@@ -55,4 +63,5 @@ export declare class HttpClientService {
     protected requestAccessToken(additionalOpts?: {}): Promise<TokenSet>;
     protected exchangeAccessToken(accessToken: string): Promise<TokenSet>;
     provideExternalToken(token: string): Promise<void>;
+    private requestPromise;
 }

package/src/lib/services/http-client.service.js

@@ -21,19 +21,12 @@ class HttpClientService {
         this.put = (url, data, config) => this.request('PUT', url, config, data);
         this.patch = (url, data, config) => this.request('PATCH', url, config, data);
         this.request = (method, url, config = {}, data) => {
-            return this.requestQueue.add(() => new Promise((resolve, reject) => {
-                const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();
-                tokenP
-                    .then((token) => {
-                    const headers = { Authorization: `Bearer ${token}`, ...config.headers };
-                    if (this.activeOrg) {
-                        headers[constants_1.ACTIVE_ORG_ID_HEADER] = this.activeOrg;
-                    }
-                    return this.axiosInstance.request({ ...config, headers, method, url, data });
-                })
-                    .then((response) => resolve(response.data))
-                    .catch(reject);
-            }));
+            if (this.requestQueue) {
+                return this.requestQueue.add(() => this.requestPromise(method, url, config, data));
+            }
+            else {
+                return this.requestPromise(method, url, config, data);
+            }
         };
         this.getAccessToken = async (forceRefresh = false) => {
             let accessToken;
@@ -57,6 +50,21 @@ class HttpClientService {
                 return accessToken;
             }
         };
+        this.requestPromise = (method, url, config = {}, data) => {
+            return new Promise((resolve, reject) => {
+                const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();
+                tokenP
+                    .then((token) => {
+                    const headers = { Authorization: `Bearer ${token}`, ...config.headers };
+                    if (this.activeOrg) {
+                        headers[constants_1.ACTIVE_ORG_ID_HEADER] = this.activeOrg;
+                    }
+                    return this.axiosInstance.request({ ...config, headers, method, url, data });
+                })
+                    .then((response) => resolve(response.data))
+                    .catch(reject);
+            });
+        };
         this.baseURL = config.baseURL;
         this.authBaseURL = config.authBaseURL || config.baseURL;
         this.realm = config.realm;
@@ -66,7 +74,18 @@ class HttpClientService {
         this.activeOrg = config.activeOrg;
         this.axiosInstance = axios_1.default.create({ baseURL: this.baseURL, timeout: 60000 });
         this.authAxiosInstance = axios_1.default.create({ baseURL: this.authBaseURL, timeout: 10000 });
-        this.requestQueue = new queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
+        if (config.queueOptions) {
+            this.requestQueue = new queue_1.Queue(config.queueOptions);
+        }
+    }
+    /**
+     * Add a response interceptor to the axios instance.
+     * @param onFulfilled Function to handle successful responses
+     * @param onRejected Function to handle response errors
+     * @returns Interceptor ID that can be used to remove the interceptor
+     */
+    addResponseInterceptor(onFulfilled, onRejected) {
+        return this.axiosInstance.interceptors.response.use(onFulfilled, onRejected);
     }
     getSseObservable(path) {
         return new rxjs_1.Observable((subscriber) => {

package/src/lib/services/notification-rule.service.d.ts

@@ -1,6 +1,12 @@
-import { HttpClientService } from '.';
+import { DataService, HttpClientService } from '.';
+import { APIBase } from '../api-base';
 import { NotificationRule } from '../interfaces';
 import { ShareService } from './share.service';
-export declare class NotificationRuleService extends ShareService<NotificationRule> {
+interface BaseService extends DataService<NotificationRule>, ShareService {
+}
+declare class BaseService extends APIBase {
+}
+export declare class NotificationRuleService extends BaseService {
     constructor(httpClient: HttpClientService);
 }
+export {};