@hahnpro/hpc-api 2026.8.4 → 2026.8.6

package/src/lib/interfaces/websockets.interface.d.ts

@@ -1,3 +1,9 @@
+export interface WebSocketError {
+    type: 'error';
+    message: string;
+    status: number;
+    retryable: boolean;
+}
 export declare enum WebSocketMessageType {
     AI_ABORTED = "ai_aborted",
     AI_ABORTING = "ai_aborting",

package/src/lib/mock/api.mock.d.ts

@@ -4,6 +4,7 @@ import { AiMockService } from './ai.mock.service';
 import { AlertMockService } from './alert.mock.service';
 import { AssetMockService } from './asset.mock.service';
 import { AssetTypesMockService } from './assetTypes.mock.service';
+import { AuthzMockService } from './authz';
 import { ContentMockService } from './content.mock.service';
 import { CrmMockService } from './crm.mock.service';
 import { DataspaceMockService } from './dataspace.mock.service';
@@ -58,6 +59,7 @@ export declare class MockAPI implements API {
     alerts: AlertMockService;
     assets: AssetMockService;
     assetTypes: AssetTypesMockService;
+    authz: AuthzMockService;
     contents: ContentMockService;
     crm: CrmMockService;
     dataspace: DataspaceMockService;

package/src/lib/mock/api.mock.js

@@ -6,6 +6,7 @@ const ai_mock_service_1 = require("./ai.mock.service");
 const alert_mock_service_1 = require("./alert.mock.service");
 const asset_mock_service_1 = require("./asset.mock.service");
 const assetTypes_mock_service_1 = require("./assetTypes.mock.service");
+const authz_1 = require("./authz");
 const content_mock_service_1 = require("./content.mock.service");
 const crm_mock_service_1 = require("./crm.mock.service");
 const dataspace_mock_service_1 = require("./dataspace.mock.service");
@@ -214,6 +215,7 @@ class MockAPI {
         this.alerts = new alert_mock_service_1.AlertMockService([]);
         this.assets = new asset_mock_service_1.AssetMockService(this, assets1, assetRevisions1);
         this.assetTypes = new assetTypes_mock_service_1.AssetTypesMockService(assetTypes, []);
+        this.authz = new authz_1.AuthzMockService();
         this.contents = new content_mock_service_1.ContentMockService(contents1, contentData);
         this.crm = new crm_mock_service_1.CrmMockService();
         this.dataspace = new dataspace_mock_service_1.DataspaceMockService();

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

@@ -0,0 +1,21 @@
+import { AuthzService } from '../../services';
+import { CapabilityBundleService } from '../../services/authz/capability-bundle.service';
+import { CapabilityService } from '../../services/authz/capability.service';
+import { OrgGroupCapabilityBundleService } from '../../services/authz/org-group-capability-bundle.service';
+import { OrgGroupCapabilityService } from '../../services/authz/org-group-capability.service';
+import { OrgGroupMemberService } from '../../services/authz/org-group-member.service';
+import { OrgGroupService } from '../../services/authz/org-group.service';
+import { OrgSubscriptionService } from '../../services/authz/org-subscription.service';
+import { UserCapabilitiesAndPermissionsService } from '../../services/authz/user-capabilities-and-permissions.service';
+import { APIBaseMock } from '../api-base.mock';
+export declare class AuthzMockService extends APIBaseMock<never> implements AuthzService {
+    readonly capabilities: CapabilityService;
+    readonly capabilityBundles: CapabilityBundleService;
+    readonly orgGroups: OrgGroupService;
+    readonly orgGroupCapabilities: OrgGroupCapabilityService;
+    readonly orgGroupCapabilityBundles: OrgGroupCapabilityBundleService;
+    readonly orgGroupMembers: OrgGroupMemberService;
+    readonly orgSubscriptions: OrgSubscriptionService;
+    readonly userCapabilitiesAndPermissions: UserCapabilitiesAndPermissionsService;
+    constructor();
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthzMockService = void 0;
+const api_base_mock_1 = require("../api-base.mock");
+const capability_bundle_mock_service_1 = require("./capability-bundle.mock.service");
+const capability_mock_service_1 = require("./capability.mock.service");
+const org_group_capability_bundle_mock_service_1 = require("./org-group-capability-bundle.mock.service");
+const org_group_capability_mock_service_1 = require("./org-group-capability.mock.service");
+const org_group_member_mock_service_1 = require("./org-group-member.mock.service");
+const org_group_mock_service_1 = require("./org-group.mock.service");
+const org_subscription_mock_service_1 = require("./org-subscription.mock.service");
+const user_capabilities_and_permissions_mock_service_1 = require("./user-capabilities-and-permissions.mock.service");
+class AuthzMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+        this.capabilities = new capability_mock_service_1.CapabilityMockService();
+        this.capabilityBundles = new capability_bundle_mock_service_1.CapabilityBundleMockService();
+        this.orgGroups = new org_group_mock_service_1.OrgGroupMockService();
+        this.orgGroupCapabilities = new org_group_capability_mock_service_1.OrgGroupCapabilityMockService();
+        this.orgGroupCapabilityBundles = new org_group_capability_bundle_mock_service_1.OrgGroupCapabilityBundleMockService();
+        this.orgGroupMembers = new org_group_member_mock_service_1.OrgGroupMemberMockService();
+        this.orgSubscriptions = new org_subscription_mock_service_1.OrgSubscriptionMockService();
+        this.userCapabilitiesAndPermissions = new user_capabilities_and_permissions_mock_service_1.UserCapabilitiesAndPermissionsMockService();
+    }
+}
+exports.AuthzMockService = AuthzMockService;

package/src/lib/mock/authz/capability-bundle.mock.service.d.ts

@@ -0,0 +1,6 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { CapabilityBundleService } from '../../services/authz/capability-bundle.service';
+export declare class CapabilityBundleMockService extends APIBaseMock<never> implements CapabilityBundleService {
+    constructor();
+    getCapabilityBundlesForOrg(): ReturnType<CapabilityBundleService['getCapabilityBundlesForOrg']>;
+}

package/src/lib/mock/authz/capability-bundle.mock.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityBundleMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class CapabilityBundleMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getCapabilityBundlesForOrg() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.CapabilityBundleMockService = CapabilityBundleMockService;

package/src/lib/mock/authz/capability.mock.service.d.ts

@@ -0,0 +1,6 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { CapabilityService } from '../../services/authz/capability.service';
+export declare class CapabilityMockService extends APIBaseMock<never> implements CapabilityService {
+    constructor();
+    getCapabilitiesForOrg(): ReturnType<CapabilityService['getCapabilitiesForOrg']>;
+}

package/src/lib/mock/authz/capability.mock.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class CapabilityMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getCapabilitiesForOrg() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.CapabilityMockService = CapabilityMockService;

package/src/lib/mock/authz/index.d.ts

@@ -0,0 +1 @@
+export { AuthzMockService } from './authz.mock.service';

package/src/lib/mock/authz/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthzMockService = void 0;
+var authz_mock_service_1 = require("./authz.mock.service");
+Object.defineProperty(exports, "AuthzMockService", { enumerable: true, get: function () { return authz_mock_service_1.AuthzMockService; } });

package/src/lib/mock/authz/org-group-capability-bundle.mock.service.d.ts

@@ -0,0 +1,9 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { OrgGroupCapabilityBundleService } from '../../services/authz/org-group-capability-bundle.service';
+export declare class OrgGroupCapabilityBundleMockService extends APIBaseMock<never> implements OrgGroupCapabilityBundleService {
+    constructor();
+    getOrgGroupCapabilityBundles(): ReturnType<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundles']>;
+    getOrgGroupCapabilityBundle(): ReturnType<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundle']>;
+    createOrgGroupCapabilityBundle(): ReturnType<OrgGroupCapabilityBundleService['createOrgGroupCapabilityBundle']>;
+    deleteOrgGroupCapabilityBundle(): ReturnType<OrgGroupCapabilityBundleService['deleteOrgGroupCapabilityBundle']>;
+}

package/src/lib/mock/authz/org-group-capability-bundle.mock.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupCapabilityBundleMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class OrgGroupCapabilityBundleMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getOrgGroupCapabilityBundles() {
+        throw new Error('Method not implemented.');
+    }
+    getOrgGroupCapabilityBundle() {
+        throw new Error('Method not implemented.');
+    }
+    createOrgGroupCapabilityBundle() {
+        throw new Error('Method not implemented.');
+    }
+    deleteOrgGroupCapabilityBundle() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OrgGroupCapabilityBundleMockService = OrgGroupCapabilityBundleMockService;

package/src/lib/mock/authz/org-group-capability.mock.service.d.ts

@@ -0,0 +1,9 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { OrgGroupCapabilityService } from '../../services/authz/org-group-capability.service';
+export declare class OrgGroupCapabilityMockService extends APIBaseMock<never> implements OrgGroupCapabilityService {
+    constructor();
+    getOrgGroupCapabilities(): ReturnType<OrgGroupCapabilityService['getOrgGroupCapabilities']>;
+    getOrgGroupCapability(): ReturnType<OrgGroupCapabilityService['getOrgGroupCapability']>;
+    createOrgGroupCapability(): ReturnType<OrgGroupCapabilityService['createOrgGroupCapability']>;
+    deleteOrgGroupCapability(): ReturnType<OrgGroupCapabilityService['deleteOrgGroupCapability']>;
+}

package/src/lib/mock/authz/org-group-capability.mock.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupCapabilityMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class OrgGroupCapabilityMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getOrgGroupCapabilities() {
+        throw new Error('Method not implemented.');
+    }
+    getOrgGroupCapability() {
+        throw new Error('Method not implemented.');
+    }
+    createOrgGroupCapability() {
+        throw new Error('Method not implemented.');
+    }
+    deleteOrgGroupCapability() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OrgGroupCapabilityMockService = OrgGroupCapabilityMockService;

package/src/lib/mock/authz/org-group-member.mock.service.d.ts

@@ -0,0 +1,8 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { OrgGroupMemberService } from '../../services/authz/org-group-member.service';
+export declare class OrgGroupMemberMockService extends APIBaseMock<never> implements OrgGroupMemberService {
+    constructor();
+    getOrgGroupMembers(): ReturnType<OrgGroupMemberService['getOrgGroupMembers']>;
+    addUserToOrgGroup(): ReturnType<OrgGroupMemberService['addUserToOrgGroup']>;
+    removeUserFromOrgGroup(): ReturnType<OrgGroupMemberService['removeUserFromOrgGroup']>;
+}

package/src/lib/mock/authz/org-group-member.mock.service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupMemberMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class OrgGroupMemberMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getOrgGroupMembers() {
+        throw new Error('Method not implemented.');
+    }
+    addUserToOrgGroup() {
+        throw new Error('Method not implemented.');
+    }
+    removeUserFromOrgGroup() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OrgGroupMemberMockService = OrgGroupMemberMockService;

package/src/lib/mock/authz/org-group.mock.service.d.ts

@@ -0,0 +1,10 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { OrgGroupService } from '../../services/authz/org-group.service';
+export declare class OrgGroupMockService extends APIBaseMock<never> implements OrgGroupService {
+    constructor();
+    getOrgGroupsByOrgId(): ReturnType<OrgGroupService['getOrgGroupsByOrgId']>;
+    getOrgGroupById(): ReturnType<OrgGroupService['getOrgGroupById']>;
+    createOrgGroup(): ReturnType<OrgGroupService['createOrgGroup']>;
+    updateOrgGroup(): ReturnType<OrgGroupService['updateOrgGroup']>;
+    deleteOrgGroup(): ReturnType<OrgGroupService['deleteOrgGroup']>;
+}

package/src/lib/mock/authz/org-group.mock.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class OrgGroupMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getOrgGroupsByOrgId() {
+        throw new Error('Method not implemented.');
+    }
+    getOrgGroupById() {
+        throw new Error('Method not implemented.');
+    }
+    createOrgGroup() {
+        throw new Error('Method not implemented.');
+    }
+    updateOrgGroup() {
+        throw new Error('Method not implemented.');
+    }
+    deleteOrgGroup() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OrgGroupMockService = OrgGroupMockService;

package/src/lib/mock/authz/org-subscription.mock.service.d.ts

@@ -0,0 +1,10 @@
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { OrgSubscriptionService } from '../../services/authz/org-subscription.service';
+export declare class OrgSubscriptionMockService extends APIBaseMock<never> implements OrgSubscriptionService {
+    constructor();
+    getOrgSubscriptionsByOrgId(): ReturnType<OrgSubscriptionService['getOrgSubscriptionsByOrgId']>;
+    getOrgSubscriptionById(): ReturnType<OrgSubscriptionService['getOrgSubscriptionById']>;
+    createOrgSubscription(): ReturnType<OrgSubscriptionService['createOrgSubscription']>;
+    updateOrgSubscription(): ReturnType<OrgSubscriptionService['updateOrgSubscription']>;
+    deleteOrgSubscription(): ReturnType<OrgSubscriptionService['deleteOrgSubscription']>;
+}

package/src/lib/mock/authz/org-subscription.mock.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgSubscriptionMockService = void 0;
+const api_base_mock_1 = require("../../mock/api-base.mock");
+class OrgSubscriptionMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getOrgSubscriptionsByOrgId() {
+        throw new Error('Method not implemented.');
+    }
+    getOrgSubscriptionById() {
+        throw new Error('Method not implemented.');
+    }
+    createOrgSubscription() {
+        throw new Error('Method not implemented.');
+    }
+    updateOrgSubscription() {
+        throw new Error('Method not implemented.');
+    }
+    deleteOrgSubscription() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OrgSubscriptionMockService = OrgSubscriptionMockService;

package/src/lib/mock/authz/user-capabilities-and-permissions.mock.service.d.ts

@@ -0,0 +1,9 @@
+import { Permission } from '../../interfaces';
+import { CapabilityId } from '../../interfaces/authz';
+import { UserCapabilitiesAndPermissionsService } from '../../services/authz/user-capabilities-and-permissions.service';
+import { APIBaseMock } from '../api-base.mock';
+export declare class UserCapabilitiesAndPermissionsMockService extends APIBaseMock<never> implements UserCapabilitiesAndPermissionsService {
+    constructor();
+    getUserCapabilitiesAndPermissions(): Promise<CapabilityId[]>;
+    getUserPermissions(): Promise<Permission[]>;
+}

package/src/lib/mock/authz/user-capabilities-and-permissions.mock.service.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserCapabilitiesAndPermissionsMockService = void 0;
+const api_base_mock_1 = require("../api-base.mock");
+class UserCapabilitiesAndPermissionsMockService extends api_base_mock_1.APIBaseMock {
+    constructor() {
+        super(null);
+    }
+    getUserCapabilitiesAndPermissions() {
+        throw new Error('Method not implemented.');
+    }
+    getUserPermissions() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.UserCapabilitiesAndPermissionsMockService = UserCapabilitiesAndPermissionsMockService;

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

@@ -32,3 +32,4 @@ export { TaskMockService } from './task.mock.service';
 export { TimeseriesMockService } from './timeseries.mock.service';
 export { UserMockService } from './user.mock.service';
 export { VaultMockService } from './vault.mock.service';
+export * from './authz';

package/src/lib/mock/index.js

@@ -69,3 +69,4 @@ var user_mock_service_1 = require("./user.mock.service");
 Object.defineProperty(exports, "UserMockService", { enumerable: true, get: function () { return user_mock_service_1.UserMockService; } });
 var vault_mock_service_1 = require("./vault.mock.service");
 Object.defineProperty(exports, "VaultMockService", { enumerable: true, get: function () { return vault_mock_service_1.VaultMockService; } });
+tslib_1.__exportStar(require("./authz"), exports);

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

@@ -1,5 +1,6 @@
 import { DeleteQuery, Paginated, RequestParameter, Task } from '../interfaces';
 import { TaskService } from '../services';
+import type { CreateAbsenceRequest } from '../services/task.service';
 import { DataMockService } from './data.mock.service';
 import { ShareMockService } from './share.mock.service';
 import { TrashMockService } from './trash.mock.service';
@@ -13,6 +14,7 @@ declare class BaseService extends BaseService_base {
 export declare class TaskMockService extends BaseService implements TaskService {
     constructor(tasks: Task[]);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
+    createAbsence(dto: CreateAbsenceRequest): Promise<Task>;
     deleteOne(taskId: string, deleteQuery?: DeleteQuery): Promise<Task>;
     getMany(params?: RequestParameter): Promise<Paginated<Task>>;
     findByName(name: string, options?: any): Promise<Paginated<Task>>;

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

@@ -15,6 +15,15 @@ class TaskMockService extends BaseService {
         this.data.push(dto);
         return Promise.resolve(dto);
     }
+    async createAbsence(dto) {
+        return this.addOne({
+            ...dto,
+            name: `Absence ${dto.startDate} - ${dto.endDate}`,
+            assignedTo: [],
+            readPermissions: [],
+            readWritePermissions: [],
+        });
+    }
     deleteOne(taskId, deleteQuery = {}) {
         const task = this.data.find((v) => v.id === taskId);
         if (!task?.deletedAt && !deleteQuery.force) {

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

@@ -0,0 +1,21 @@
+import { APIBase } from '../../api-base';
+import { HttpClientService } from '../http-client.service';
+import { CapabilityBundleService } from './capability-bundle.service';
+import { CapabilityService } from './capability.service';
+import { OrgGroupCapabilityBundleService } from './org-group-capability-bundle.service';
+import { OrgGroupCapabilityService } from './org-group-capability.service';
+import { OrgGroupMemberService } from './org-group-member.service';
+import { OrgGroupService } from './org-group.service';
+import { OrgSubscriptionService } from './org-subscription.service';
+import { UserCapabilitiesAndPermissionsService } from './user-capabilities-and-permissions.service';
+export declare class AuthzService extends APIBase {
+    readonly capabilities: CapabilityService;
+    readonly capabilityBundles: CapabilityBundleService;
+    readonly orgGroups: OrgGroupService;
+    readonly orgGroupCapabilities: OrgGroupCapabilityService;
+    readonly orgGroupCapabilityBundles: OrgGroupCapabilityBundleService;
+    readonly orgGroupMembers: OrgGroupMemberService;
+    readonly orgSubscriptions: OrgSubscriptionService;
+    readonly userCapabilitiesAndPermissions: UserCapabilitiesAndPermissionsService;
+    constructor(httpClient: HttpClientService);
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthzService = void 0;
+const api_base_1 = require("../../api-base");
+const capability_bundle_service_1 = require("./capability-bundle.service");
+const capability_service_1 = require("./capability.service");
+const org_group_capability_bundle_service_1 = require("./org-group-capability-bundle.service");
+const org_group_capability_service_1 = require("./org-group-capability.service");
+const org_group_member_service_1 = require("./org-group-member.service");
+const org_group_service_1 = require("./org-group.service");
+const org_subscription_service_1 = require("./org-subscription.service");
+const user_capabilities_and_permissions_service_1 = require("./user-capabilities-and-permissions.service");
+class AuthzService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz');
+        this.capabilities = new capability_service_1.CapabilityService(httpClient);
+        this.capabilityBundles = new capability_bundle_service_1.CapabilityBundleService(httpClient);
+        this.orgGroups = new org_group_service_1.OrgGroupService(httpClient);
+        this.orgGroupCapabilities = new org_group_capability_service_1.OrgGroupCapabilityService(httpClient);
+        this.orgGroupCapabilityBundles = new org_group_capability_bundle_service_1.OrgGroupCapabilityBundleService(httpClient);
+        this.orgGroupMembers = new org_group_member_service_1.OrgGroupMemberService(httpClient);
+        this.orgSubscriptions = new org_subscription_service_1.OrgSubscriptionService(httpClient);
+        this.userCapabilitiesAndPermissions = new user_capabilities_and_permissions_service_1.UserCapabilitiesAndPermissionsService(httpClient);
+    }
+}
+exports.AuthzService = AuthzService;

package/src/lib/services/authz/capability-bundle.service.d.ts

@@ -0,0 +1,7 @@
+import { APIBase } from '../../api-base';
+import type { CapabilityBundle, SqlPagination } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class CapabilityBundleService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getCapabilityBundlesForOrg(orgId: string, sqlPagination?: SqlPagination): Promise<CapabilityBundle[]>;
+}

package/src/lib/services/authz/capability-bundle.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityBundleService = void 0;
+const api_base_1 = require("../../api-base");
+class CapabilityBundleService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/capability-bundles');
+    }
+    getCapabilityBundlesForOrg(orgId, sqlPagination = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgId}`, { params: sqlPagination });
+    }
+}
+exports.CapabilityBundleService = CapabilityBundleService;

package/src/lib/services/authz/capability.service.d.ts

@@ -0,0 +1,7 @@
+import { APIBase } from '../../api-base';
+import type { Capability, SqlPagination } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class CapabilityService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getCapabilitiesForOrg(orgId: string, sqlPagination?: SqlPagination): Promise<Capability[]>;
+}

package/src/lib/services/authz/capability.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityService = void 0;
+const api_base_1 = require("../../api-base");
+class CapabilityService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/capabilities');
+    }
+    getCapabilitiesForOrg(orgId, sqlPagination = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgId}`, { params: sqlPagination });
+    }
+}
+exports.CapabilityService = CapabilityService;

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

@@ -0,0 +1 @@
+export { AuthzService } from './authz.service';

package/src/lib/services/authz/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthzService = void 0;
+var authz_service_1 = require("./authz.service");
+Object.defineProperty(exports, "AuthzService", { enumerable: true, get: function () { return authz_service_1.AuthzService; } });

package/src/lib/services/authz/org-group-capability-bundle.service.d.ts

@@ -0,0 +1,10 @@
+import { APIBase } from '../../api-base';
+import type { CapabilityBundleId, CreateOrgGroupCapabilityBundle, OrgGroupCapabilityBundle, SqlPagination } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class OrgGroupCapabilityBundleService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getOrgGroupCapabilityBundles(orgGroupId: string, sqlPagination?: SqlPagination): Promise<OrgGroupCapabilityBundle[]>;
+    getOrgGroupCapabilityBundle(orgGroupId: string, capabilityBundleId: CapabilityBundleId): Promise<OrgGroupCapabilityBundle>;
+    createOrgGroupCapabilityBundle(createOrgGroupCapabilityBundle: CreateOrgGroupCapabilityBundle): Promise<OrgGroupCapabilityBundle>;
+    deleteOrgGroupCapabilityBundle(orgGroupId: string, capabilityBundleId: CapabilityBundleId): Promise<void>;
+}

package/src/lib/services/authz/org-group-capability-bundle.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupCapabilityBundleService = void 0;
+const api_base_1 = require("../../api-base");
+class OrgGroupCapabilityBundleService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/org-group-capabilities-bundles');
+    }
+    getOrgGroupCapabilityBundles(orgGroupId, sqlPagination = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, { params: sqlPagination });
+    }
+    getOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`);
+    }
+    createOrgGroupCapabilityBundle(createOrgGroupCapabilityBundle) {
+        return this.httpClient.post(this.basePath, createOrgGroupCapabilityBundle);
+    }
+    deleteOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`);
+    }
+}
+exports.OrgGroupCapabilityBundleService = OrgGroupCapabilityBundleService;

package/src/lib/services/authz/org-group-capability.service.d.ts

@@ -0,0 +1,10 @@
+import { APIBase } from '../../api-base';
+import type { CapabilityId, CreateOrgGroupCapability, OrgGroupCapability, SqlPagination } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class OrgGroupCapabilityService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getOrgGroupCapabilities(orgGroupId: string, sqlPagination?: SqlPagination): Promise<OrgGroupCapability[]>;
+    getOrgGroupCapability(orgGroupId: string, capabilityId: CapabilityId): Promise<OrgGroupCapability>;
+    createOrgGroupCapability(createOrgGroupCapability: CreateOrgGroupCapability): Promise<OrgGroupCapability>;
+    deleteOrgGroupCapability(orgGroupId: string, capabilityId: CapabilityId): Promise<void>;
+}

package/src/lib/services/authz/org-group-capability.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupCapabilityService = void 0;
+const api_base_1 = require("../../api-base");
+class OrgGroupCapabilityService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/org-group-capabilities');
+    }
+    getOrgGroupCapabilities(orgGroupId, sqlPagination = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, { params: sqlPagination });
+    }
+    getOrgGroupCapability(orgGroupId, capabilityId) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityId}`);
+    }
+    createOrgGroupCapability(createOrgGroupCapability) {
+        return this.httpClient.post(this.basePath, createOrgGroupCapability);
+    }
+    deleteOrgGroupCapability(orgGroupId, capabilityId) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityId}`);
+    }
+}
+exports.OrgGroupCapabilityService = OrgGroupCapabilityService;

package/src/lib/services/authz/org-group-member.service.d.ts

@@ -0,0 +1,9 @@
+import { APIBase } from '../../api-base';
+import type { CreateOrgGroupMember, SqlPagination, SqlPaginationResult } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class OrgGroupMemberService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getOrgGroupMembers(orgGroupId: string, sqlPagination?: SqlPagination): Promise<SqlPaginationResult<string>>;
+    addUserToOrgGroup(createOrgGroupMember: CreateOrgGroupMember): Promise<void>;
+    removeUserFromOrgGroup(orgGroupId: string, userId: string): Promise<void>;
+}

package/src/lib/services/authz/org-group-member.service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgGroupMemberService = void 0;
+const api_base_1 = require("../../api-base");
+class OrgGroupMemberService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/org-group-members');
+    }
+    getOrgGroupMembers(orgGroupId, sqlPagination = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, { params: sqlPagination });
+    }
+    addUserToOrgGroup(createOrgGroupMember) {
+        return this.httpClient.post(this.basePath, createOrgGroupMember);
+    }
+    removeUserFromOrgGroup(orgGroupId, userId) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${userId}`);
+    }
+}
+exports.OrgGroupMemberService = OrgGroupMemberService;

package/src/lib/services/authz/org-group.service.d.ts

@@ -0,0 +1,11 @@
+import { APIBase } from '../../api-base';
+import type { CreateOrgGroup, OrgGroup, SqlPagination, SqlPaginationResult, UpdateOrgGroup } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class OrgGroupService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getOrgGroupsByOrgId(orgId: string, sqlPagination?: SqlPagination): Promise<SqlPaginationResult<OrgGroup>>;
+    getOrgGroupById(orgGroupId: string): Promise<OrgGroup>;
+    createOrgGroup(createOrgGroup: CreateOrgGroup): Promise<OrgGroup>;
+    updateOrgGroup(orgGroupId: string, updateOrgGroup: UpdateOrgGroup): Promise<OrgGroup>;
+    deleteOrgGroup(orgGroupId: string): Promise<void>;
+}