@hahnpro/hpc-api 2025.3.10 → 2025.4.0

package/src/lib/{data.service.js → services/data.service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataService = void 0;
-const api_base_1 = require("./api-base");
-const data_interface_1 = require("./data.interface");
+const api_base_1 = require("../api-base");
+const utils_1 = require("../utils");
 class DataService extends api_base_1.APIBase {
     addOne(dto, options = {}) {
         return this.httpClient.post(this.basePath, dto, options);
@@ -30,7 +30,7 @@ class DataService extends api_base_1.APIBase {
      * @param options Parameters for authentication
      */
     getManyFiltered(filter, params = {}, options = {}) {
-        params.filter = this.getFilterString(filter);
+        params.filter = (0, utils_1.getFilterString)(filter);
         return this.getMany(params, options);
     }
     updateOne(id, dto, options = {}) {
@@ -39,23 +39,5 @@ class DataService extends api_base_1.APIBase {
     deleteOne(id, force = false, options = {}) {
         return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
     }
-    getFilterString(filter) {
-        const filters = [];
-        for (const [key, value] of Object.entries(filter)) {
-            if (value != null && value !== '') {
-                // filter out null and undefined values and empty strings
-                if (typeof value === 'object' && (0, data_interface_1.instanceOfTimePeriod)(value)) {
-                    filters.push(`${key}>=${value.from.toISOString()};${key}<=${value.to.toISOString()}`);
-                }
-                else if (Array.isArray(value)) {
-                    filters.push(`${key}=@${value.join(',')}`);
-                }
-                else {
-                    filters.push(`${key}==${value}`);
-                }
-            }
-        }
-        return filters.join(';');
-    }
 }
 exports.DataService = DataService;

package/src/lib/{endpoint.service.d.ts → services/endpoint.service.d.ts}

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

package/src/lib/{endpoint.service.js → services/endpoint.service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointService = void 0;
-const data_service_1 = require("./data.service");
-class EndpointService extends data_service_1.DataService {
+const _1 = require(".");
+class EndpointService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/notification/endpoints');
     }

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

@@ -1,8 +1,7 @@
-import { DataService } from '../data.service';
-import { HttpClient, TokenOption } from '../http.service';
-import { Event } from '../interfaces';
+import { DataService, HttpClientService } from '.';
+import { Event, TokenOption } from '../interfaces';
 export declare class EventService extends DataService<Event> {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     getLastEventByAssetAndGroup(assetId: string, group: string, options?: TokenOption): Promise<Event>;
     getLastEventByAssetAndGroups(assetId: string, groups: string[], options?: TokenOption): Promise<Record<string, string>>;
 }

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventService = void 0;
-const data_service_1 = require("../data.service");
-class EventService extends data_service_1.DataService {
+const _1 = require(".");
+class EventService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/events');
     }

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

@@ -1,15 +1,12 @@
-import { APIBase } from './api-base';
-import { DataService } from './data.service';
-import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from './flow-deployment.interface';
-import { HttpClient, TokenOption } from './http.service';
-import { ResourceReference } from './interfaces';
-import { TrashService } from './trash.service';
+import { DataService, HttpClientService, TrashService } from '.';
+import { APIBase } from '../api-base';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog, ResourceReference, TokenOption } from '../interfaces';
 interface BaseService extends DataService<FlowDeployment>, TrashService<FlowDeployment> {
 }
 declare class BaseService extends APIBase {
 }
 export declare class FlowDeploymentService extends BaseService {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     addMany(dto: any[], options?: TokenOption): Promise<FlowDeployment[]>;
     updateOne(id: string, dto: any, options?: TokenOption & {
         force: boolean;

package/src/lib/{flow-deployment.service.js → services/flow-deployment.service.js}

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowDeploymentService = 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 trash_service_1 = require("./trash.service");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, _1.TrashService)
 ], BaseService);
 class FlowDeploymentService extends BaseService {
     constructor(httpClient) {

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

@@ -1,11 +1,9 @@
-import { Paginated } from './data.interface';
-import { DataService } from './data.service';
-import { FlowFunctionDto } from './flow-function.interface';
-import { HttpClient, TokenOption } from './http.service';
+import { DataService, HttpClientService } from '.';
+import { FlowFunctionDto, Paginated, TokenOption } from '../interfaces';
 export declare class FlowFunctionService extends DataService<FlowFunctionDto> {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     addMany(dto: any[], options?: TokenOption): Promise<FlowFunctionDto[]>;
-    getRevisions(fqn: string, options?: TokenOption): Promise<Paginated<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/src/lib/{flow-function.service.js → services/flow-function.service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowFunctionService = void 0;
-const data_service_1 = require("./data.service");
-class FlowFunctionService extends data_service_1.DataService {
+const _1 = require(".");
+class FlowFunctionService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/functions');
     }

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

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

package/src/lib/{flow-module.service.js → services/flow-module.service.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowModuleService = void 0;
-const data_service_1 = require("./data.service");
-const utils_1 = require("./utils");
-class FlowModuleService extends data_service_1.DataService {
+const _1 = require(".");
+const utils_1 = require("../utils");
+class FlowModuleService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');
     }

package/src/lib/{flow.service.d.ts → services/flow.service.d.ts}

@@ -1,25 +1,21 @@
-import { APIBase } from './api-base';
-import { Paginated, RequestParameter } from './data.interface';
-import { DataService } from './data.service';
-import { FlowDeployment } from './flow-deployment.interface';
-import { FlowDiagram, FlowDto } from './flow.interface';
-import { HttpClient, TokenOption } from './http.service';
-import { TrashService } from './trash.service';
+import { DataService, HttpClientService, TrashService } from '.';
+import { APIBase } from '../api-base';
+import { FlowDeployment, FlowDiagram, FlowDto, Paginated, RequestParameter, TokenOption } from '../interfaces';
 interface BaseService extends DataService<FlowDto>, TrashService<FlowDto> {
 }
 declare class BaseService extends APIBase {
 }
 export declare class FlowService extends BaseService {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     addMany(dto: any[], options?: TokenOption): Promise<FlowDto[]>;
-    getMany(params?: RequestParameter, options?: TokenOption): Promise<Paginated<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[]>>;
+    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>;
 }

package/src/lib/{flow.service.js → services/flow.service.js}

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowService = 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 trash_service_1 = require("./trash.service");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, _1.TrashService)
 ], BaseService);
 class FlowService extends BaseService {
     constructor(httpClient) {

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

@@ -1,12 +1,11 @@
-import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
+import { EventSourceMessage } from '@microsoft/fetch-event-source';
+import { AxiosInstance, 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 {
+import { Observable, Subject } from 'rxjs';
+import { Config, Issuer, TokenOption } from '../interfaces';
+import { Queue } from '../queue';
+import { TokenSet } from '../token-set';
+export declare class HttpClientService {
     protected readonly baseURL: string;
     protected readonly authBaseURL: string;
     protected readonly realm: string;
@@ -37,6 +36,7 @@ export declare class HttpClient {
     put: <T>(url: string, data: any, config?: Config) => Promise<T>;
     patch: <T>(url: string, data: any, config?: Config) => Promise<T>;
     protected request: <T>(method: Method, url: string, config?: Config, data?: any) => Promise<T>;
+    getSseObservable<T>(path: string, onmessage?: (subject: Subject<T>, event: EventSourceMessage) => void): Observable<T>;
     addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
     destroyEventSource(id: string): void;
     destroyAllEventSources(): void;
@@ -47,11 +47,3 @@ export declare class HttpClient {
     protected exchangeAccessToken(accessToken: string): Promise<TokenSet>;
     provideExternalToken(token: string): Promise<void>;
 }
-export interface Issuer {
-    issuer: string;
-    token_endpoint: string;
-    grant_types_supported: string[];
-    token_endpoint_auth_methods_supported: string[];
-    token_endpoint_auth_signing_alg?: string;
-    token_endpoint_auth_signing_alg_values_supported: string[];
-}

package/src/lib/{http.service.js → services/http-client.service.js}

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpClient = void 0;
+exports.HttpClientService = void 0;
 const tslib_1 = require("tslib");
+const fetch_event_source_1 = require("@microsoft/fetch-event-source");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const eventsource_1 = require("eventsource");
 const jose_1 = require("jose");
-const Queue_1 = require("./Queue");
-const token_set_1 = require("./token-set");
-class HttpClient {
+const rxjs_1 = require("rxjs");
+const queue_1 = require("../queue");
+const token_set_1 = require("../token-set");
+class HttpClientService {
     constructor(baseURL, authBaseURL, realm, clientId, clientSecret, tokenSubject) {
         this.baseURL = baseURL;
         this.authBaseURL = authBaseURL;
@@ -59,7 +61,41 @@ class HttpClient {
         };
         this.axiosInstance = axios_1.default.create({ baseURL, timeout: 60000 });
         this.authAxiosInstance = axios_1.default.create({ baseURL: authBaseURL || baseURL, timeout: 10000 });
-        this.requestQueue = new Queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
+        this.requestQueue = new queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
+    }
+    getSseObservable(path, onmessage) {
+        const subject = new rxjs_1.Subject();
+        this.getAccessToken()
+            .then((token) => {
+            const ctrl = new AbortController();
+            (0, fetch_event_source_1.fetchEventSource)(`${this.baseURL}/${path}`, {
+                headers: { authorization: 'Bearer ' + token },
+                signal: ctrl.signal,
+                onopen: async (response) => {
+                    if (!response.ok) {
+                        subject.error(new Error(`HTTP ${response.status}: ${response.statusText}`));
+                        ctrl.abort();
+                    }
+                },
+                onmessage(event) {
+                    if (onmessage) {
+                        onmessage(subject, event);
+                    }
+                },
+                onclose() {
+                    subject.complete();
+                    ctrl.abort();
+                },
+                onerror(err) {
+                    subject.error(err);
+                    ctrl.abort();
+                },
+            });
+        })
+            .catch((err) => {
+            subject.error(err);
+        });
+        return subject.asObservable();
     }
     async addEventSource(url, listener, errorListener, options = {}) {
         const id = globalThis.crypto.randomUUID();
@@ -181,4 +217,4 @@ class HttpClient {
         this.tokenSet = new token_set_1.TokenSet(token, exp - Date.now() / 1000, true);
     }
 }
-exports.HttpClient = HttpClient;
+exports.HttpClientService = HttpClientService;

package/src/lib/services/index.d.ts

@@ -1,7 +1,27 @@
+export { DataService } from './data.service';
+export { TrashService } from './trash.service';
 export { AiService } from './ai.service';
+export { AlertService } from './alert.service';
 export { AssetService } from './asset.service';
 export { AssetTypesService } from './assettypes.service';
+export { ContentService } from './content.service';
+export { EndpointService } from './endpoint.service';
 export { EventService } from './event.service';
+export { FlowService } from './flow.service';
+export { FlowDeploymentService } from './flow-deployment.service';
+export { FlowFunctionService } from './flow-function.service';
+export { FlowModuleService } from './flow-module.service';
+export { HttpClientService } from './http-client.service';
 export { LabelService } from './label.service';
+export { NotificationRuleService } from './notification-rule.service';
+export { NotificationService } from './notification.service';
+export { OrganizationsService } from './organizations.service';
+export { OrganizationsAdministrationService } from './organizations-administration.service';
+export { OrganizationsResourcesService } from './organizations-resources.service';
+export { ProxyService } from './proxy.service';
 export { SearchService } from './search.service';
+export { SecretService } from './secret.service';
+export { TaskService } from './task.service';
 export { TimeSeriesService } from './timeseries.service';
+export { UserService } from './user.service';
+export { VaultService } from './vault.service';

package/src/lib/services/index.js

@@ -1,17 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeSeriesService = exports.SearchService = exports.LabelService = exports.EventService = exports.AssetTypesService = exports.AssetService = exports.AiService = void 0;
+exports.VaultService = exports.UserService = exports.TimeSeriesService = exports.TaskService = exports.SecretService = exports.SearchService = exports.ProxyService = exports.OrganizationsResourcesService = exports.OrganizationsAdministrationService = exports.OrganizationsService = exports.NotificationService = exports.NotificationRuleService = exports.LabelService = exports.HttpClientService = exports.FlowModuleService = exports.FlowFunctionService = exports.FlowDeploymentService = exports.FlowService = exports.EventService = exports.EndpointService = exports.ContentService = exports.AssetTypesService = exports.AssetService = exports.AlertService = exports.AiService = exports.TrashService = exports.DataService = void 0;
+var data_service_1 = require("./data.service");
+Object.defineProperty(exports, "DataService", { enumerable: true, get: function () { return data_service_1.DataService; } });
+var trash_service_1 = require("./trash.service");
+Object.defineProperty(exports, "TrashService", { enumerable: true, get: function () { return trash_service_1.TrashService; } });
 var ai_service_1 = require("./ai.service");
 Object.defineProperty(exports, "AiService", { enumerable: true, get: function () { return ai_service_1.AiService; } });
+var alert_service_1 = require("./alert.service");
+Object.defineProperty(exports, "AlertService", { enumerable: true, get: function () { return alert_service_1.AlertService; } });
 var asset_service_1 = require("./asset.service");
 Object.defineProperty(exports, "AssetService", { enumerable: true, get: function () { return asset_service_1.AssetService; } });
 var assettypes_service_1 = require("./assettypes.service");
 Object.defineProperty(exports, "AssetTypesService", { enumerable: true, get: function () { return assettypes_service_1.AssetTypesService; } });
+var content_service_1 = require("./content.service");
+Object.defineProperty(exports, "ContentService", { enumerable: true, get: function () { return content_service_1.ContentService; } });
+var endpoint_service_1 = require("./endpoint.service");
+Object.defineProperty(exports, "EndpointService", { enumerable: true, get: function () { return endpoint_service_1.EndpointService; } });
 var event_service_1 = require("./event.service");
 Object.defineProperty(exports, "EventService", { enumerable: true, get: function () { return event_service_1.EventService; } });
+var flow_service_1 = require("./flow.service");
+Object.defineProperty(exports, "FlowService", { enumerable: true, get: function () { return flow_service_1.FlowService; } });
+var flow_deployment_service_1 = require("./flow-deployment.service");
+Object.defineProperty(exports, "FlowDeploymentService", { enumerable: true, get: function () { return flow_deployment_service_1.FlowDeploymentService; } });
+var flow_function_service_1 = require("./flow-function.service");
+Object.defineProperty(exports, "FlowFunctionService", { enumerable: true, get: function () { return flow_function_service_1.FlowFunctionService; } });
+var flow_module_service_1 = require("./flow-module.service");
+Object.defineProperty(exports, "FlowModuleService", { enumerable: true, get: function () { return flow_module_service_1.FlowModuleService; } });
+var http_client_service_1 = require("./http-client.service");
+Object.defineProperty(exports, "HttpClientService", { enumerable: true, get: function () { return http_client_service_1.HttpClientService; } });
 var label_service_1 = require("./label.service");
 Object.defineProperty(exports, "LabelService", { enumerable: true, get: function () { return label_service_1.LabelService; } });
+var notification_rule_service_1 = require("./notification-rule.service");
+Object.defineProperty(exports, "NotificationRuleService", { enumerable: true, get: function () { return notification_rule_service_1.NotificationRuleService; } });
+var notification_service_1 = require("./notification.service");
+Object.defineProperty(exports, "NotificationService", { enumerable: true, get: function () { return notification_service_1.NotificationService; } });
+var organizations_service_1 = require("./organizations.service");
+Object.defineProperty(exports, "OrganizationsService", { enumerable: true, get: function () { return organizations_service_1.OrganizationsService; } });
+var organizations_administration_service_1 = require("./organizations-administration.service");
+Object.defineProperty(exports, "OrganizationsAdministrationService", { enumerable: true, get: function () { return organizations_administration_service_1.OrganizationsAdministrationService; } });
+var organizations_resources_service_1 = require("./organizations-resources.service");
+Object.defineProperty(exports, "OrganizationsResourcesService", { enumerable: true, get: function () { return organizations_resources_service_1.OrganizationsResourcesService; } });
+var proxy_service_1 = require("./proxy.service");
+Object.defineProperty(exports, "ProxyService", { enumerable: true, get: function () { return proxy_service_1.ProxyService; } });
 var search_service_1 = require("./search.service");
 Object.defineProperty(exports, "SearchService", { enumerable: true, get: function () { return search_service_1.SearchService; } });
+var secret_service_1 = require("./secret.service");
+Object.defineProperty(exports, "SecretService", { enumerable: true, get: function () { return secret_service_1.SecretService; } });
+var task_service_1 = require("./task.service");
+Object.defineProperty(exports, "TaskService", { enumerable: true, get: function () { return task_service_1.TaskService; } });
 var timeseries_service_1 = require("./timeseries.service");
 Object.defineProperty(exports, "TimeSeriesService", { enumerable: true, get: function () { return timeseries_service_1.TimeSeriesService; } });
+var user_service_1 = require("./user.service");
+Object.defineProperty(exports, "UserService", { enumerable: true, get: function () { return user_service_1.UserService; } });
+var vault_service_1 = require("./vault.service");
+Object.defineProperty(exports, "VaultService", { enumerable: true, get: function () { return vault_service_1.VaultService; } });

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

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

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LabelService = void 0;
-const data_service_1 = require("../data.service");
-class LabelService extends data_service_1.DataService {
+const _1 = require(".");
+class LabelService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/labels');
     }

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

@@ -0,0 +1,5 @@
+import { DataService, HttpClientService } from '.';
+import { NotificationRule } from '../interfaces';
+export declare class NotificationRuleService extends DataService<NotificationRule> {
+    constructor(httpClient: HttpClientService);
+}

package/src/lib/{notification-rule.service.js → services/notification-rule.service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationRuleService = void 0;
-const data_service_1 = require("./data.service");
-class NotificationRuleService extends data_service_1.DataService {
+const _1 = require(".");
+class NotificationRuleService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/notification/rules');
     }

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

@@ -0,0 +1,5 @@
+import { DataService, HttpClientService } from '.';
+import { Notification } from '../interfaces';
+export declare class NotificationService extends DataService<Notification> {
+    constructor(httpClient: HttpClientService);
+}

package/src/lib/{notification.service.js → services/notification.service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationService = void 0;
-const data_service_1 = require("./data.service");
-class NotificationService extends data_service_1.DataService {
+const _1 = require(".");
+class NotificationService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/notifications');
     }

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

@@ -0,0 +1,56 @@
+import { APIBase } from '../api-base';
+import { Filter, Organization, OrganizationCreateDto, OrganizationSearchQuery, Paginated, RequestParameter, SubscriptionType, UserWithOrgRoles } from '../interfaces';
+import { HttpClientService } from './';
+/**
+ * Service for managing organizations with administrative privileges (superuser role required).
+ */
+export declare class OrganizationsAdministrationService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    /**
+     * Gets one organization by id, combining data from Keycloak and MongoDB.
+     *
+     * @param {string} id - The ID of the organization to retrieve.
+     * @returns {Promise<Organization>} - An promise containing the combined organization data from Keycloak and MongoDB.
+     */
+    getOneCombined(id: string): Promise<Organization>;
+    /**
+     * Get many organizations with pagination, filtering, and sorting options.
+     *
+     * @param {RequestParameter} params - The request parameters for pagination, filtering, and sorting.
+     * @returns {Promise<Paginated<Organization>>} - An observable containing the paginated list of organizations.
+     */
+    getMany(params?: RequestParameter): Promise<Paginated<Organization>>;
+    /**
+     * Get many organizations filtered by specific properties with pagination, filtering, and sorting options.
+     *
+     * @param {Filter} filter - The filter object containing properties to filter by.
+     * @param {RequestParameter} params - The request parameters for pagination, filtering, and sorting.
+     * @returns {Promise<Paginated<Organization>>} - An observable containing the paginated list of organizations.
+     */
+    getManyFiltered(filter: Filter, params?: RequestParameter): Promise<Paginated<Organization>>;
+    /**
+     * Searches for all organizations using the organization client.
+     *
+     * @param {OrganizationSearchQuery} query - The search query object containing optional filters.
+     * @param {string} query.name - The name of the organization to filter by (optional).
+     * @returns {Promise<Organization[]>} - An observable containing an array of organizations matching the query.
+     */
+    searchAllOrganizationWithOrganizationClient(query: OrganizationSearchQuery): Promise<Organization[]>;
+    /**
+     * Creates an organization with a free subscription and invites a user to that organization
+     *
+     * @param {OrganizationCreateDto} organizationCreateDto - The data transfer object containing the organization details for creation
+     * @param {string} userEmail - The email address of the user to be invited to the organization
+     * @returns {Promise<Organization>} - An observable containing the created organization
+     */
+    createFreeOrgAndInviteUser(organizationCreateDto: OrganizationCreateDto, userEmail: string): Promise<Organization>;
+    addOrganizationMembers(id: string, usersWithOrgRoles: UserWithOrgRoles[]): Promise<void>;
+    addSubscriptionToOrganization(id: string, type: SubscriptionType): Promise<Organization>;
+    /**
+     * Deletes an organization.
+     *
+     * @param {string} id - organization id
+     * @returns {Promise<void>} - Promise resolving to void
+     */
+    deleteOne(id: string): Promise<void>;
+}