@hahnpro/hpc-api 2026.7.5 → 2026.7.7

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

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimeseriesMockService = void 0;
-const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
-const _1 = require(".");
+const data_mock_service_1 = require("./data.mock.service");
 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)(_1.DataMockService, share_mock_service_1.ShareMockService, _1.TrashMockService)
-], BaseService);
+const trash_mock_service_1 = require("./trash.mock.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_mock_service_1.DataMockService), (share_mock_service_1.ShareMockService), (trash_mock_service_1.TrashMockService)) {
+}
 class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {
         const data = timeseries.map((value, index) => ({ ...value, data: timeseriesValues[index] }));

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

@@ -1,11 +1,11 @@
-import { APIBaseMock } from '.';
 import { Paginated, RequestParameter } from '../interfaces';
 import { TrashService } from '../services';
+import { APIBaseMock } from './api-base.mock';
 export declare class TrashMockService<T extends {
     id?: string;
     fqn?: string;
 }> extends APIBaseMock<T> implements TrashService<T> {
-    constructor();
+    constructor(data?: T[]);
     trashRestoreAll(): Promise<T[]>;
     trashRestoreOne(id: string): Promise<T>;
     emptyTrash(offset: number): Promise<{

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashMockService = void 0;
-const _1 = require(".");
-class TrashMockService extends _1.APIBaseMock {
-    constructor() {
-        super(null);
+const api_base_mock_1 = require("./api-base.mock");
+class TrashMockService extends api_base_mock_1.APIBaseMock {
+    constructor(data = []) {
+        super(data);
     }
     trashRestoreAll() {
         const deleted = this.data.filter((v) => v['deletedAt']);

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

@@ -1,5 +1,5 @@
 import { UserService } from '../services';
-import { UserInit } from './api.mock';
+import type { UserInit } from './api.mock';
 export declare class UserMockService extends UserService {
     private users;
     constructor(users: UserInit);

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

@@ -1,6 +1,6 @@
-import { DataMockService } from '.';
 import { VaultSecret } from '../interfaces';
 import { VaultService } from '../services';
+import { DataMockService } from './data.mock.service';
 export declare class VaultMockService extends DataMockService<VaultSecret> implements VaultService {
     constructor(secrets: VaultSecret[]);
     getSecret(name: string, version?: number): Promise<string>;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultMockService = void 0;
-const _1 = require(".");
-class VaultMockService extends _1.DataMockService {
+const data_mock_service_1 = require("./data.mock.service");
+class VaultMockService extends data_mock_service_1.DataMockService {
     constructor(secrets) {
         super();
         this.data = secrets;

package/src/lib/queue.d.ts

@@ -1,9 +1,14 @@
-import PQueue from 'p-queue';
+import PQueue, { type QueueAddOptions } from 'p-queue';
 declare const PQueueBase: typeof PQueue;
+type QueueTask<TaskResultType> = (options: {
+    readonly signal?: AbortSignal;
+}) => PromiseLike<TaskResultType> | TaskResultType;
 export declare class Queue extends PQueueBase {
     private peak;
     private total;
-    constructor(options: QueueOptions);
+    private readonly throwOnTimeout;
+    constructor({ throwOnTimeout, ...options }: QueueOptions);
+    add<TaskResultType>(function_: QueueTask<TaskResultType>, options?: Partial<QueueAddOptions>): Promise<TaskResultType>;
     getStats(): {
         peak: number;
         pending: number;

package/src/lib/queue.js

@@ -5,10 +5,11 @@ const tslib_1 = require("tslib");
 const p_queue_1 = tslib_1.__importDefault(require("p-queue"));
 const PQueueBase = p_queue_1.default.default ?? p_queue_1.default;
 class Queue extends PQueueBase {
-    constructor(options) {
+    constructor({ throwOnTimeout = false, ...options }) {
         super(options);
         this.peak = 0;
         this.total = 0;
+        this.throwOnTimeout = throwOnTimeout;
         this.on('add', () => {
             this.peak = Math.max(this.peak, this.size);
         });
@@ -16,6 +17,17 @@ class Queue extends PQueueBase {
             this.total++;
         });
     }
+    async add(function_, options) {
+        try {
+            return await super.add(function_, options);
+        }
+        catch (error) {
+            if (!this.throwOnTimeout && error instanceof Error && error.name === 'TimeoutError') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
     getStats() {
         return {
             peak: this.peak,

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

@@ -1,6 +1,7 @@
-import { HttpClientService } from '.';
 import { APIBase } from '../api-base';
-import { AiAssistant, AiAssistantId, Message, OneShotTaskId, OneShotTaskResult, Paginated, SpeechToken, Thread, ThreadPopulated, TokenOption } from '../interfaces';
+import { AiAssistant, AiAssistantId, AiSkill, AiSkillSummary, Config, Message, OneShotTaskId, OneShotTaskResult, Paginated, SpeechToken, Thread, ThreadPopulated, TokenOption } from '../interfaces';
+import { CrossPlatformFormData } from '../utils';
+import { HttpClientService } from './http-client.service';
 export declare class AiService extends APIBase {
     constructor(httpClient: HttpClientService);
     addMessage(message: string, threadId?: string, assistantId?: AiAssistantId, context?: Record<string, unknown>, attachmentIds?: string[]): Promise<Message>;
@@ -10,6 +11,12 @@ export declare class AiService extends APIBase {
     getAssistant(assistantId: AiAssistantId): Promise<AiAssistant>;
     getAssistants(options?: TokenOption): Promise<AiAssistant[]>;
     getSpeechToken(): Promise<SpeechToken>;
+    getSkills(options?: Config): Promise<AiSkillSummary[]>;
+    setSkillEnabled(id: string, enabled: boolean, options?: Config): Promise<AiSkill>;
+    deleteSkill(id: string, options?: Config): Promise<AiSkill>;
+    exportSkill(id: string, options?: Config): Promise<Blob>;
+    importSkill(form: CrossPlatformFormData, options?: Config): Promise<AiSkill>;
+    replaceSkill(id: string, form: CrossPlatformFormData, options?: Config): Promise<AiSkill>;
     getThreadMessages(threadId: string): Promise<Paginated<Message>>;
     getThread(threadId: string): Promise<ThreadPopulated>;
     getLatestThread(): Promise<ThreadPopulated>;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiService = void 0;
 const api_base_1 = require("../api-base");
+const utils_1 = require("../utils");
 class AiService extends api_base_1.APIBase {
     constructor(httpClient) {
         super(httpClient, '/ai');
@@ -27,6 +28,26 @@ class AiService extends api_base_1.APIBase {
     getSpeechToken() {
         return this.httpClient.get(`${this.basePath}/speech/token`);
     }
+    getSkills(options = {}) {
+        return this.httpClient.get(`${this.basePath}/skills`, options);
+    }
+    setSkillEnabled(id, enabled, options = {}) {
+        return this.httpClient.put(`${this.basePath}/skills/${id}`, { enabled }, options);
+    }
+    deleteSkill(id, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/skills/${id}`, options);
+    }
+    exportSkill(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/skills/${id}/export`, { responseType: 'blob', ...options });
+    }
+    importSkill(form, options = {}) {
+        const headers = { ...(0, utils_1.getFormDataHeaders)(form), ...options.headers };
+        return this.httpClient.post(`${this.basePath}/skills/import`, form, { ...options, headers });
+    }
+    replaceSkill(id, form, options = {}) {
+        const headers = { ...(0, utils_1.getFormDataHeaders)(form), ...options.headers };
+        return this.httpClient.put(`${this.basePath}/skills/${id}/package`, form, { ...options, headers });
+    }
     getThreadMessages(threadId) {
         return this.httpClient.get(`${this.basePath}/threads/${threadId}/messages`);
     }

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

@@ -1,11 +1,11 @@
-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';
-interface BaseService extends DataService<Alert>, ShareService {
-}
-declare class BaseService extends APIBase {
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<Alert> & ShareService, {
+    new (httpClient: HttpClientService, basePath: string): DataService<Alert>;
+} & typeof ShareService>;
+declare class BaseService extends BaseService_base {
 }
 export declare class AlertService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,11 @@
 "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");
-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 BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService) {
+}
 class AlertService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/alerts');

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

@@ -1,11 +1,15 @@
-import { DataService, HttpClientService, TrashService } from '.';
-import { APIBase } from '../api-base';
 import { AddToProperty, Asset, AssetRevision, Attachment, DeleteAssetQuery, EventCause, EventLevelOverride, Filter, Paginated, RemoveFromProperty, RequestParameter, TokenOption, type SearchResult } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<Asset>, ShareService, TrashService<Asset> {
-}
-declare class BaseService extends APIBase {
+import { TrashService } from './trash.service';
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<Asset> & ShareService & TrashService<Asset>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<Asset>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<Asset>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class AssetService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetService = 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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService, _1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+const trash_service_1 = require("./trash.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class AssetService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assets');

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

@@ -1,12 +1,14 @@
-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 DataService<AssetType>, ShareService, TrashService<AssetType> {
-}
-declare class BaseService extends APIBase {
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<AssetType> & ShareService & TrashService<AssetType>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<AssetType>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<AssetType>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class AssetTypesService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,18 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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)(data_service_1.DataService, share_service_1.ShareService, trash_service_1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class AssetTypesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assettypes');

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

@@ -1,11 +1,15 @@
-import { DataService, HttpClientService, TrashService } from '.';
-import { APIBase } from '../api-base';
 import { Config, Content, ReturnType, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<Content>, ShareService, TrashService<Content> {
-}
-declare class BaseService extends APIBase {
+import { TrashService } from './trash.service';
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<Content> & ShareService & TrashService<Content>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<Content>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<Content>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class ContentService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,19 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentService = 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 interfaces_1 = require("../interfaces");
 const utils_1 = require("../utils");
+const data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService, _1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+const trash_service_1 = require("./trash.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class ContentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/contents');

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

@@ -1,10 +1,11 @@
-import { DataService, HttpClientService } from '.';
-import { APIBase } from '../api-base';
 import { Endpoint, EndpointLog, NotificationPayload, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<Endpoint>, ShareService {
-}
-declare class BaseService extends APIBase {
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<Endpoint> & ShareService, {
+    new (httpClient: HttpClientService, basePath: string): DataService<Endpoint>;
+} & typeof ShareService>;
+declare class BaseService extends BaseService_base {
 }
 export declare class EndpointService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,11 @@
 "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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService) {
+}
 class EndpointService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/notification/endpoints');

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

@@ -1,10 +1,11 @@
-import { DataService, HttpClientService } from '.';
-import { APIBase } from '../api-base';
 import { Event, EventCountByAsset, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<Event>, ShareService {
-}
-declare class BaseService extends APIBase {
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<Event> & ShareService, {
+    new (httpClient: HttpClientService, basePath: string): DataService<Event>;
+} & typeof ShareService>;
+declare class BaseService extends BaseService_base {
 }
 export declare class EventService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,11 @@
 "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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService) {
+}
 class EventService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/events');

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

@@ -1,10 +1,14 @@
-import { DataService, HttpClientService, TrashService } from '.';
-import { APIBase } from '../api-base';
 import { DeleteQuery, FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog, NatsFlowTriggerData, NatsFlowTriggerState, ResourceReference, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<FlowDeployment>, ShareService, TrashService<FlowDeployment> {
-}
-declare class BaseService extends APIBase {
+import { TrashService } from './trash.service';
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<FlowDeployment> & ShareService & TrashService<FlowDeployment>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<FlowDeployment>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<FlowDeployment>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class FlowDeploymentService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowDeploymentService = 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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService, _1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+const trash_service_1 = require("./trash.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class FlowDeploymentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/deployments');

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

@@ -1,10 +1,14 @@
-import { DataService, HttpClientService, TrashService } from '.';
-import { APIBase } from '../api-base';
 import { FlowFunctionDto, Paginated, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<FlowFunctionDto>, ShareService, TrashService<FlowFunctionDto> {
-}
-declare class BaseService extends APIBase {
+import { TrashService } from './trash.service';
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<import("../interfaces").FlowFunction> & ShareService & TrashService<import("../interfaces").FlowFunction>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<import("../interfaces").FlowFunction>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<import("../interfaces").FlowFunction>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class FlowFunctionService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,12 @@
 "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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService, _1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+const trash_service_1 = require("./trash.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class FlowFunctionService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/functions');

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

@@ -1,11 +1,12 @@
-import { DataService, HttpClientService } from '.';
-import { APIBase } from '../api-base';
 import { FlowModule, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<FlowModule>, ShareService {
-}
-declare class BaseService extends APIBase {
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<FlowModule> & ShareService, {
+    new (httpClient: HttpClientService, basePath: string): DataService<FlowModule>;
+} & typeof ShareService>;
+declare class BaseService extends BaseService_base {
 }
 export declare class FlowModuleService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,18 +1,12 @@
 "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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService) {
+}
 class FlowModuleService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');

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

@@ -1,10 +1,14 @@
-import { DataService, HttpClientService, TrashService } from '.';
-import { APIBase } from '../api-base';
 import { FlowDeployment, FlowDiagram, FlowDto, Paginated, RequestParameter, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 import { ShareService } from './share.service';
-interface BaseService extends DataService<FlowDto>, ShareService, TrashService<FlowDto> {
-}
-declare class BaseService extends APIBase {
+import { TrashService } from './trash.service';
+declare const BaseService_base: import("ts-mixer/dist/types/types").Class<any[], DataService<FlowDto> & ShareService & TrashService<FlowDto>, {
+    new (httpClient: HttpClientService, basePath: string): DataService<FlowDto>;
+} & typeof ShareService & {
+    new (httpClient: HttpClientService, basePath: string): TrashService<FlowDto>;
+}>;
+declare class BaseService extends BaseService_base {
 }
 export declare class FlowService extends BaseService {
     constructor(httpClient: HttpClientService);

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

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowService = 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 data_service_1 = require("./data.service");
 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)(_1.DataService, share_service_1.ShareService, _1.TrashService)
-], BaseService);
-/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+const trash_service_1 = require("./trash.service");
+class BaseService extends (0, ts_mixer_1.Mixin)((data_service_1.DataService), share_service_1.ShareService, (trash_service_1.TrashService)) {
+}
 class FlowService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flows');

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

@@ -1,5 +1,6 @@
-import { DataService, HttpClientService } from '.';
 import type { Label, SearchOptions, SearchResult, TokenOption } from '../interfaces';
+import { DataService } from './data.service';
+import { HttpClientService } from './http-client.service';
 export declare class LabelService extends DataService<Label> {
     constructor(httpClient: HttpClientService);
     addMany(dtos: Label[], options?: TokenOption): Promise<Label[]>;