@hahnpro/hpc-api 2026.9.9 → 2026.9.10

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

@@ -6,16 +6,16 @@ class OrgGroupCapabilityBundleMockService extends api_base_mock_1.APIBaseMock {
     constructor() {
         super(null);
     }
-    getOrgGroupCapabilityBundles() {
+    getOrgGroupCapabilityBundles(..._args) {
         throw new Error('Method not implemented.');
     }
-    getOrgGroupCapabilityBundle() {
+    getOrgGroupCapabilityBundle(..._args) {
         throw new Error('Method not implemented.');
     }
-    createOrgGroupCapabilityBundle() {
+    createOrgGroupCapabilityBundle(..._args) {
         throw new Error('Method not implemented.');
     }
-    deleteOrgGroupCapabilityBundle() {
+    deleteOrgGroupCapabilityBundle(..._args) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -2,8 +2,8 @@ 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']>;
+    getOrgGroupCapabilities(..._args: Parameters<OrgGroupCapabilityService['getOrgGroupCapabilities']>): ReturnType<OrgGroupCapabilityService['getOrgGroupCapabilities']>;
+    getOrgGroupCapability(..._args: Parameters<OrgGroupCapabilityService['getOrgGroupCapability']>): ReturnType<OrgGroupCapabilityService['getOrgGroupCapability']>;
+    createOrgGroupCapability(..._args: Parameters<OrgGroupCapabilityService['createOrgGroupCapability']>): ReturnType<OrgGroupCapabilityService['createOrgGroupCapability']>;
+    deleteOrgGroupCapability(..._args: Parameters<OrgGroupCapabilityService['deleteOrgGroupCapability']>): ReturnType<OrgGroupCapabilityService['deleteOrgGroupCapability']>;
 }

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

@@ -6,16 +6,16 @@ class OrgGroupCapabilityMockService extends api_base_mock_1.APIBaseMock {
     constructor() {
         super(null);
     }
-    getOrgGroupCapabilities() {
+    getOrgGroupCapabilities(..._args) {
         throw new Error('Method not implemented.');
     }
-    getOrgGroupCapability() {
+    getOrgGroupCapability(..._args) {
         throw new Error('Method not implemented.');
     }
-    createOrgGroupCapability() {
+    createOrgGroupCapability(..._args) {
         throw new Error('Method not implemented.');
     }
-    deleteOrgGroupCapability() {
+    deleteOrgGroupCapability(..._args) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -2,7 +2,7 @@ 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']>;
+    getOrgGroupMembers(..._args: Parameters<OrgGroupMemberService['getOrgGroupMembers']>): ReturnType<OrgGroupMemberService['getOrgGroupMembers']>;
+    addUserToOrgGroup(..._args: Parameters<OrgGroupMemberService['addUserToOrgGroup']>): ReturnType<OrgGroupMemberService['addUserToOrgGroup']>;
+    removeUserFromOrgGroup(..._args: Parameters<OrgGroupMemberService['removeUserFromOrgGroup']>): ReturnType<OrgGroupMemberService['removeUserFromOrgGroup']>;
 }

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

@@ -6,13 +6,13 @@ class OrgGroupMemberMockService extends api_base_mock_1.APIBaseMock {
     constructor() {
         super(null);
     }
-    getOrgGroupMembers() {
+    getOrgGroupMembers(..._args) {
         throw new Error('Method not implemented.');
     }
-    addUserToOrgGroup() {
+    addUserToOrgGroup(..._args) {
         throw new Error('Method not implemented.');
     }
-    removeUserFromOrgGroup() {
+    removeUserFromOrgGroup(..._args) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -2,9 +2,9 @@ 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']>;
+    getOrgGroupsOfUsersActiveOrg(..._args: Parameters<OrgGroupService['getOrgGroupsOfUsersActiveOrg']>): ReturnType<OrgGroupService['getOrgGroupsOfUsersActiveOrg']>;
+    getOrgGroupById(..._args: Parameters<OrgGroupService['getOrgGroupById']>): ReturnType<OrgGroupService['getOrgGroupById']>;
+    createOrgGroup(..._args: Parameters<OrgGroupService['createOrgGroup']>): ReturnType<OrgGroupService['createOrgGroup']>;
+    updateOrgGroup(..._args: Parameters<OrgGroupService['updateOrgGroup']>): ReturnType<OrgGroupService['updateOrgGroup']>;
+    deleteOrgGroup(..._args: Parameters<OrgGroupService['deleteOrgGroup']>): ReturnType<OrgGroupService['deleteOrgGroup']>;
 }

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

@@ -6,19 +6,19 @@ class OrgGroupMockService extends api_base_mock_1.APIBaseMock {
     constructor() {
         super(null);
     }
-    getOrgGroupsByOrgId() {
+    getOrgGroupsOfUsersActiveOrg(..._args) {
         throw new Error('Method not implemented.');
     }
-    getOrgGroupById() {
+    getOrgGroupById(..._args) {
         throw new Error('Method not implemented.');
     }
-    createOrgGroup() {
+    createOrgGroup(..._args) {
         throw new Error('Method not implemented.');
     }
-    updateOrgGroup() {
+    updateOrgGroup(..._args) {
         throw new Error('Method not implemented.');
     }
-    deleteOrgGroup() {
+    deleteOrgGroup(..._args) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -2,9 +2,6 @@ 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']>;
+    getOrgSubscriptionsByOrgId(..._args: Parameters<OrgSubscriptionService['getOrgSubscriptionsByOrgId']>): ReturnType<OrgSubscriptionService['getOrgSubscriptionsByOrgId']>;
+    getOrgSubscriptionById(..._args: Parameters<OrgSubscriptionService['getOrgSubscriptionById']>): ReturnType<OrgSubscriptionService['getOrgSubscriptionById']>;
 }

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

@@ -6,19 +6,10 @@ class OrgSubscriptionMockService extends api_base_mock_1.APIBaseMock {
     constructor() {
         super(null);
     }
-    getOrgSubscriptionsByOrgId() {
+    getOrgSubscriptionsByOrgId(..._args) {
         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() {
+    getOrgSubscriptionById(..._args) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -51,7 +51,7 @@ export declare class TimeseriesMockService extends BaseService implements TimeSe
     getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries>>;
     getMostRecentValue(id: string, before: Date): Promise<TimeSeriesValue>;
     getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
-    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
+    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS, _options?: {}, limit?: number): Promise<TimeSeriesValue[]>;
     getMostRecentTimeSeriesValueByAssetAndTimeSeriesName(assetId: string, timeSeriesNames: string[]): Promise<Record<string, any>>;
 }
 export {};

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

@@ -126,15 +126,16 @@ class TimeseriesMockService extends BaseService {
         return null;
     }
     async getValues(id, from, limit, group) {
-        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
+        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().valueOf(), group, {}, limit);
         if (limit) {
             timeSeriesValues = timeSeriesValues.slice(0, limit);
         }
         return timeSeriesValues;
     }
-    async getValuesOfPeriod(id, from, to, group) {
+    async getValuesOfPeriod(id, from, to, group, _options = {}, limit) {
         const ts = await this.getOne(id, {});
-        return ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
+        const values = ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
+        return limit ? values.slice(0, limit) : values;
     }
     getMostRecentTimeSeriesValueByAssetAndTimeSeriesName(assetId, timeSeriesNames) {
         const result = Object.fromEntries(timeSeriesNames.map((name) => [name, '']));

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

@@ -0,0 +1,11 @@
+import { APIBase } from '../../api-base';
+import { CapabilityId, Permission, TokenOption } from '../../interfaces';
+import type { Capability, CapabilityBundle, SqlPagination } from '../../interfaces/authz';
+import { HttpClientService } from '../http-client.service';
+export declare class AuthorizationService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    getOrgCapabilitiesForActiveSubscription(sqlPagination?: SqlPagination, options?: TokenOption): Promise<Capability[]>;
+    getOrgCapabilityBundlesForActiveSubscription(sqlPagination?: SqlPagination, options?: TokenOption): Promise<CapabilityBundle[]>;
+    getCapabilitiesForUsersActiveOrg(options?: TokenOption): Promise<CapabilityId[]>;
+    getPermissionsForUsersActiveOrg(options?: TokenOption): Promise<Permission[]>;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationService = void 0;
+const api_base_1 = require("../../api-base");
+class AuthorizationService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/authz/authorization');
+    }
+    getOrgCapabilitiesForActiveSubscription(sqlPagination = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/org/capabilities`, { ...options, params: sqlPagination });
+    }
+    getOrgCapabilityBundlesForActiveSubscription(sqlPagination = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/org/capability-bundles`, { ...options, params: sqlPagination });
+    }
+    getCapabilitiesForUsersActiveOrg(options = {}) {
+        return this.httpClient.get(`${this.basePath}/user/capabilities`, options);
+    }
+    getPermissionsForUsersActiveOrg(options = {}) {
+        return this.httpClient.get(`${this.basePath}/user/permissions`, options);
+    }
+}
+exports.AuthorizationService = AuthorizationService;

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

@@ -1,21 +1,17 @@
 import { APIBase } from '../../api-base';
 import { HttpClientService } from '../http-client.service';
-import { CapabilityBundleService } from './capability-bundle.service';
-import { CapabilityService } from './capability.service';
+import { AuthorizationService } from './authorization.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 authorization: AuthorizationService;
     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

@@ -2,25 +2,21 @@
 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 authorization_service_1 = require("./authorization.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.authorization = new authorization_service_1.AuthorizationService(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/org-group-capability-bundle.service.d.ts

@@ -1,10 +1,11 @@
 import { APIBase } from '../../api-base';
+import type { TokenOption } from '../../interfaces';
 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>;
+    getOrgGroupCapabilityBundles(orgGroupId: string, sqlPagination?: SqlPagination, options?: TokenOption): Promise<OrgGroupCapabilityBundle[]>;
+    getOrgGroupCapabilityBundle(orgGroupId: string, capabilityBundleId: CapabilityBundleId, options?: TokenOption): Promise<OrgGroupCapabilityBundle>;
+    createOrgGroupCapabilityBundle(createOrgGroupCapabilityBundle: CreateOrgGroupCapabilityBundle, options?: TokenOption): Promise<OrgGroupCapabilityBundle>;
+    deleteOrgGroupCapabilityBundle(orgGroupId: string, capabilityBundleId: CapabilityBundleId, options?: TokenOption): Promise<void>;
 }

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

@@ -6,17 +6,20 @@ 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 });
+    getOrgGroupCapabilityBundles(orgGroupId, sqlPagination = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, {
+            ...options,
+            params: sqlPagination,
+        });
     }
-    getOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId) {
-        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`);
+    getOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`, options);
     }
-    createOrgGroupCapabilityBundle(createOrgGroupCapabilityBundle) {
-        return this.httpClient.post(this.basePath, createOrgGroupCapabilityBundle);
+    createOrgGroupCapabilityBundle(createOrgGroupCapabilityBundle, options = {}) {
+        return this.httpClient.post(this.basePath, createOrgGroupCapabilityBundle, options);
     }
-    deleteOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId) {
-        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`);
+    deleteOrgGroupCapabilityBundle(orgGroupId, capabilityBundleId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityBundleId}`, options);
     }
 }
 exports.OrgGroupCapabilityBundleService = OrgGroupCapabilityBundleService;

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

@@ -1,10 +1,11 @@
 import { APIBase } from '../../api-base';
+import type { TokenOption } from '../../interfaces';
 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>;
+    getOrgGroupCapabilities(orgGroupId: string, sqlPagination?: SqlPagination, options?: TokenOption): Promise<OrgGroupCapability[]>;
+    getOrgGroupCapability(orgGroupId: string, capabilityId: CapabilityId, options?: TokenOption): Promise<OrgGroupCapability>;
+    createOrgGroupCapability(createOrgGroupCapability: CreateOrgGroupCapability, options?: TokenOption): Promise<OrgGroupCapability>;
+    deleteOrgGroupCapability(orgGroupId: string, capabilityId: CapabilityId, options?: TokenOption): Promise<void>;
 }

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

@@ -6,17 +6,20 @@ 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 });
+    getOrgGroupCapabilities(orgGroupId, sqlPagination = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, {
+            ...options,
+            params: sqlPagination,
+        });
     }
-    getOrgGroupCapability(orgGroupId, capabilityId) {
-        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityId}`);
+    getOrgGroupCapability(orgGroupId, capabilityId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}/${capabilityId}`, options);
     }
-    createOrgGroupCapability(createOrgGroupCapability) {
-        return this.httpClient.post(this.basePath, createOrgGroupCapability);
+    createOrgGroupCapability(createOrgGroupCapability, options = {}) {
+        return this.httpClient.post(this.basePath, createOrgGroupCapability, options);
     }
-    deleteOrgGroupCapability(orgGroupId, capabilityId) {
-        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityId}`);
+    deleteOrgGroupCapability(orgGroupId, capabilityId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${capabilityId}`, options);
     }
 }
 exports.OrgGroupCapabilityService = OrgGroupCapabilityService;

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

@@ -1,9 +1,10 @@
 import { APIBase } from '../../api-base';
+import type { TokenOption } from '../../interfaces';
 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>;
+    getOrgGroupMembers(orgGroupId: string, sqlPagination?: SqlPagination, options?: TokenOption): Promise<SqlPaginationResult<string>>;
+    addUserToOrgGroup(createOrgGroupMember: CreateOrgGroupMember, options?: TokenOption): Promise<void>;
+    removeUserFromOrgGroup(orgGroupId: string, userId: string, options?: TokenOption): Promise<void>;
 }

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

@@ -6,14 +6,17 @@ 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 });
+    getOrgGroupMembers(orgGroupId, sqlPagination = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, {
+            ...options,
+            params: sqlPagination,
+        });
     }
-    addUserToOrgGroup(createOrgGroupMember) {
-        return this.httpClient.post(this.basePath, createOrgGroupMember);
+    addUserToOrgGroup(createOrgGroupMember, options = {}) {
+        return this.httpClient.post(this.basePath, createOrgGroupMember, options);
     }
-    removeUserFromOrgGroup(orgGroupId, userId) {
-        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${userId}`);
+    removeUserFromOrgGroup(orgGroupId, userId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}/${userId}`, options);
     }
 }
 exports.OrgGroupMemberService = OrgGroupMemberService;

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

@@ -1,11 +1,12 @@
 import { APIBase } from '../../api-base';
+import type { TokenOption } from '../../interfaces';
 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>;
+    getOrgGroupsOfUsersActiveOrg(sqlPagination?: SqlPagination, options?: TokenOption): Promise<SqlPaginationResult<OrgGroup>>;
+    getOrgGroupById(orgGroupId: string, options?: TokenOption): Promise<OrgGroup>;
+    createOrgGroup(createOrgGroup: CreateOrgGroup, options?: TokenOption): Promise<OrgGroup>;
+    updateOrgGroup(orgGroupId: string, updateOrgGroup: UpdateOrgGroup, options?: TokenOption): Promise<OrgGroup>;
+    deleteOrgGroup(orgGroupId: string, options?: TokenOption): Promise<void>;
 }

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

@@ -6,20 +6,20 @@ class OrgGroupService extends api_base_1.APIBase {
     constructor(httpClient) {
         super(httpClient, '/authz/org-groups');
     }
-    getOrgGroupsByOrgId(orgId, sqlPagination = {}) {
-        return this.httpClient.get(`${this.basePath}/by-org/${orgId}`, { params: sqlPagination });
+    getOrgGroupsOfUsersActiveOrg(sqlPagination = {}, options = {}) {
+        return this.httpClient.get(this.basePath, { ...options, params: sqlPagination });
     }
-    getOrgGroupById(orgGroupId) {
-        return this.httpClient.get(`${this.basePath}/${orgGroupId}`);
+    getOrgGroupById(orgGroupId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgGroupId}`, options);
     }
-    createOrgGroup(createOrgGroup) {
-        return this.httpClient.post(this.basePath, createOrgGroup);
+    createOrgGroup(createOrgGroup, options = {}) {
+        return this.httpClient.post(this.basePath, createOrgGroup, options);
     }
-    updateOrgGroup(orgGroupId, updateOrgGroup) {
-        return this.httpClient.patch(`${this.basePath}/${orgGroupId}`, updateOrgGroup);
+    updateOrgGroup(orgGroupId, updateOrgGroup, options = {}) {
+        return this.httpClient.patch(`${this.basePath}/${orgGroupId}`, updateOrgGroup, options);
     }
-    deleteOrgGroup(orgGroupId) {
-        return this.httpClient.delete(`${this.basePath}/${orgGroupId}`);
+    deleteOrgGroup(orgGroupId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${orgGroupId}`, options);
     }
 }
 exports.OrgGroupService = OrgGroupService;

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

@@ -1,11 +1,9 @@
 import { APIBase } from '../../api-base';
-import type { CreateOrgSubscription, OrgSubscription, SqlPagination, UpdateOrgSubscription } from '../../interfaces/authz';
+import type { TokenOption } from '../../interfaces';
+import type { OrgSubscription, SqlPagination } from '../../interfaces/authz';
 import { HttpClientService } from '../http-client.service';
 export declare class OrgSubscriptionService extends APIBase {
     constructor(httpClient: HttpClientService);
-    getOrgSubscriptionsByOrgId(orgId: string, sqlPagination?: SqlPagination): Promise<OrgSubscription[]>;
-    getOrgSubscriptionById(orgSubscriptionId: string): Promise<OrgSubscription>;
-    createOrgSubscription(createOrgSubscription: CreateOrgSubscription): Promise<OrgSubscription>;
-    updateOrgSubscription(orgSubscriptionId: string, updateOrgSubscription: UpdateOrgSubscription): Promise<OrgSubscription>;
-    deleteOrgSubscription(orgSubscriptionId: string): Promise<void>;
+    getOrgSubscriptionsByOrgId(sqlPagination?: SqlPagination, options?: TokenOption): Promise<OrgSubscription[]>;
+    getOrgSubscriptionById(orgSubscriptionId: string, options?: TokenOption): Promise<OrgSubscription>;
 }

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

@@ -6,20 +6,11 @@ class OrgSubscriptionService extends api_base_1.APIBase {
     constructor(httpClient) {
         super(httpClient, '/authz/org-subscriptions');
     }
-    getOrgSubscriptionsByOrgId(orgId, sqlPagination = {}) {
-        return this.httpClient.get(`${this.basePath}/by-org/${orgId}`, { params: sqlPagination });
+    getOrgSubscriptionsByOrgId(sqlPagination = {}, options = {}) {
+        return this.httpClient.get(this.basePath, { ...options, params: sqlPagination });
     }
-    getOrgSubscriptionById(orgSubscriptionId) {
-        return this.httpClient.get(`${this.basePath}/${orgSubscriptionId}`);
-    }
-    createOrgSubscription(createOrgSubscription) {
-        return this.httpClient.post(this.basePath, createOrgSubscription);
-    }
-    updateOrgSubscription(orgSubscriptionId, updateOrgSubscription) {
-        return this.httpClient.patch(`${this.basePath}/${orgSubscriptionId}`, updateOrgSubscription);
-    }
-    deleteOrgSubscription(orgSubscriptionId) {
-        return this.httpClient.delete(`${this.basePath}/${orgSubscriptionId}`);
+    getOrgSubscriptionById(orgSubscriptionId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${orgSubscriptionId}`, options);
     }
 }
 exports.OrgSubscriptionService = OrgSubscriptionService;

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

@@ -72,7 +72,7 @@ export declare class TimeSeriesService extends BaseService {
     }, options?: TokenOption): Promise<PromiseSettledResult<TimeSeries>[]>;
     getMostRecentValue(id: string, before?: Date, options?: TokenOption): Promise<TimeSeriesValue>;
     getValues(id: string, from: number, limit?: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
-    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
+    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS, options?: TokenOption, limit?: number): Promise<TimeSeriesValue[]>;
     getManyByAsset(assetId: string, names?: string[], options?: TokenOption): Promise<Paginated<TimeSeries>>;
     getMostRecentTimeSeriesValueByAssetAndTimeSeriesName(assetId: string, timeSeriesNames: string[], options?: TokenOption): Promise<Record<string, any>>;
 }

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

@@ -86,8 +86,8 @@ class TimeSeriesService extends BaseService {
         const params = { limit, group };
         return this.httpClient.get(`${this.basePath}/${id}/${from}`, { params, ...options });
     }
-    getValuesOfPeriod(id, from, to, group, options = {}) {
-        const params = { group };
+    getValuesOfPeriod(id, from, to, group, options = {}, limit) {
+        const params = { group, limit };
         return this.httpClient.get(`${this.basePath}/${id}/${from}/${to}`, { params, ...options });
     }
     getManyByAsset(assetId, names, options = {}) {

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

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-"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/user-capabilities-and-permissions.mock.service.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,16 +0,0 @@
-"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;