@hahnpro/hpc-api 2026.9.9 → 2026.9.11

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/index.d.ts

@@ -33,3 +33,4 @@ export { TimeseriesValueFeedManagementService } from './timeseries-value-feed-ma
 export { UserService } from './user.service';
 export { VaultService } from './vault.service';
 export * from './authz';
+export * from './knowledge.service';

package/src/lib/services/index.js

@@ -71,3 +71,4 @@ Object.defineProperty(exports, "UserService", { enumerable: true, get: function
 var vault_service_1 = require("./vault.service");
 Object.defineProperty(exports, "VaultService", { enumerable: true, get: function () { return vault_service_1.VaultService; } });
 tslib_1.__exportStar(require("./authz"), exports);
+tslib_1.__exportStar(require("./knowledge.service"), exports);

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

@@ -0,0 +1,22 @@
+import { APIBase } from '../api-base';
+import type { Config, ConfirmKnowledge, CreateKnowledge, KnowledgeBacklinkQuery, KnowledgeBatch, KnowledgeHome, KnowledgeList, KnowledgePage, KnowledgeQuery, KnowledgeRevision, KnowledgeVersion, UpdateKnowledge } from '../interfaces';
+import { HttpClientService } from './http-client.service';
+export declare class KnowledgeService extends APIBase {
+    constructor(httpClient: HttpClientService);
+    addOne(dto: CreateKnowledge, options?: Config): Promise<KnowledgePage>;
+    getOne(id: string, options?: Config): Promise<KnowledgePage>;
+    getMany(query?: KnowledgeQuery, options?: Config): Promise<KnowledgeList>;
+    getHome(query?: KnowledgeQuery, options?: Config): Promise<KnowledgeHome>;
+    getBacklinks(query: KnowledgeBacklinkQuery, options?: Config): Promise<KnowledgeList>;
+    getRelated(id: string, query?: Pick<KnowledgeQuery, 'cursor' | 'limit'>, options?: Config): Promise<KnowledgeList>;
+    getRevision(id: string, revision: number, options?: Config): Promise<KnowledgeRevision>;
+    readBatch(ids: string[], options?: Config): Promise<KnowledgeBatch>;
+    updateOne(id: string, dto: UpdateKnowledge, options?: Config): Promise<KnowledgePage>;
+    confirm(id: string, dto: ConfirmKnowledge, options?: Config): Promise<KnowledgePage>;
+    withdraw(id: string, dto: KnowledgeVersion, options?: Config): Promise<KnowledgePage>;
+    restore(id: string, dto: KnowledgeVersion, options?: Config): Promise<KnowledgePage>;
+    /** Permanently deletes all pages and revisions of an organization; for organization deletion only. */
+    purgeOrganization(organizationId: string, options?: Config): Promise<{
+        deleted: number;
+    }>;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeService = void 0;
+const api_base_1 = require("../api-base");
+class KnowledgeService extends api_base_1.APIBase {
+    constructor(httpClient) {
+        super(httpClient, '/knowledge');
+    }
+    addOne(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
+    }
+    getOne(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${encodeURIComponent(id)}`, options);
+    }
+    getMany(query = {}, options = {}) {
+        return this.httpClient.get(this.basePath, { ...options, params: query });
+    }
+    getHome(query = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/home`, { ...options, params: query });
+    }
+    getBacklinks(query, options = {}) {
+        return this.httpClient.get(`${this.basePath}/backlinks`, { ...options, params: query });
+    }
+    getRelated(id, query = {}, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${encodeURIComponent(id)}/related`, { ...options, params: query });
+    }
+    getRevision(id, revision, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${encodeURIComponent(id)}/revisions/${revision}`, options);
+    }
+    readBatch(ids, options = {}) {
+        return this.httpClient.post(`${this.basePath}/read-batch`, { ids }, options);
+    }
+    updateOne(id, dto, options = {}) {
+        return this.httpClient.patch(`${this.basePath}/${encodeURIComponent(id)}`, dto, options);
+    }
+    confirm(id, dto, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${encodeURIComponent(id)}/confirm`, dto, options);
+    }
+    withdraw(id, dto, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${encodeURIComponent(id)}/withdraw`, dto, options);
+    }
+    restore(id, dto, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${encodeURIComponent(id)}/restore`, dto, options);
+    }
+    /** Permanently deletes all pages and revisions of an organization; for organization deletion only. */
+    purgeOrganization(organizationId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/organizations/${encodeURIComponent(organizationId)}`, options);
+    }
+}
+exports.KnowledgeService = KnowledgeService;

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;

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

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

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

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

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

@@ -1,9 +0,0 @@
-import { APIBase } from '../../api-base';
-import { Permission } from '../../interfaces';
-import { CapabilityId } from '../../interfaces/authz';
-import { HttpClientService } from '../http-client.service';
-export declare class UserCapabilitiesAndPermissionsService extends APIBase {
-    constructor(httpClient: HttpClientService);
-    getUserCapabilitiesAndPermissions(): Promise<CapabilityId[]>;
-    getUserPermissions(): Promise<Permission[]>;
-}

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserCapabilitiesAndPermissionsService = void 0;
-const api_base_1 = require("../../api-base");
-class UserCapabilitiesAndPermissionsService extends api_base_1.APIBase {
-    constructor(httpClient) {
-        super(httpClient, '/authz/user');
-    }
-    getUserCapabilitiesAndPermissions() {
-        return this.httpClient.get(`${this.basePath}/capabilities`);
-    }
-    getUserPermissions() {
-        return this.httpClient.get(`${this.basePath}/permissions`);
-    }
-}
-exports.UserCapabilitiesAndPermissionsService = UserCapabilitiesAndPermissionsService;