@hahnpro/hpc-api 2026.9.9 → 2026.9.11

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

@@ -2,6 +2,7 @@ export declare const NatsStreams: {
     readonly Resource: "resource";
     readonly Flows: "flows";
     readonly Audit: "audit";
+    readonly Organizations: "organizations";
 };
 export declare const NatsConsumers: {
     readonly resource: {
@@ -41,6 +42,10 @@ export declare const NatsConsumers: {
             readonly ReferenceTargetRestored: "reference-target-restored";
             readonly ReferenceCreateCommand: "reference-create-command";
         };
+        readonly OrgGroupService: {
+            readonly DeleteGroupOfDeletedOrgs: "delete-group-of-deleted-orgs";
+            readonly DeleteSubsOfDeletedOrgs: "delete-subs-of-deleted-orgs";
+        };
     };
     readonly flows: {
         readonly FlowTrigger: "flow-trigger";
@@ -53,6 +58,11 @@ export declare const NatsConsumers: {
     readonly audit: {
         readonly AuditLogger: "audit-logger";
     };
+    readonly organizations: {
+        readonly OrgGroupMembers: {
+            readonly DeleteMemberships: "delete-org-group-memberships";
+        };
+    };
 };
 export declare const natsHpcPrefix = "com.hahnpro";
 export declare const natsFlowsPrefix = "fs";

package/src/lib/interfaces/nats.interface.js

@@ -5,6 +5,7 @@ exports.NatsStreams = {
     Resource: 'resource',
     Flows: 'flows',
     Audit: 'audit',
+    Organizations: 'organizations',
 };
 exports.NatsConsumers = {
     [exports.NatsStreams.Resource]: {
@@ -44,6 +45,10 @@ exports.NatsConsumers = {
             ReferenceTargetRestored: 'reference-target-restored',
             ReferenceCreateCommand: 'reference-create-command',
         },
+        OrgGroupService: {
+            DeleteGroupOfDeletedOrgs: 'delete-group-of-deleted-orgs',
+            DeleteSubsOfDeletedOrgs: 'delete-subs-of-deleted-orgs',
+        },
     },
     [exports.NatsStreams.Flows]: {
         FlowTrigger: 'flow-trigger',
@@ -56,6 +61,11 @@ exports.NatsConsumers = {
     [exports.NatsStreams.Audit]: {
         AuditLogger: 'audit-logger',
     },
+    [exports.NatsStreams.Organizations]: {
+        OrgGroupMembers: {
+            DeleteMemberships: 'delete-org-group-memberships',
+        },
+    },
 };
 exports.natsHpcPrefix = 'com.hahnpro';
 exports.natsFlowsPrefix = 'fs';

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

@@ -11,6 +11,7 @@ export declare enum ResourceType {
     FLOWDEPLOYMENT = "flowdeployment",
     FLOWFUNCTION = "flowfunction",
     FLOWMODULE = "flowmodule",
+    KNOWLEDGE = "knowledge",
     LABEL = "label",
     LOGBOOKENTRY = "logbookentry",
     NOTIFICATIONENDPOINT = "notificationendpoint",
@@ -33,6 +34,7 @@ export declare enum ResourceApiPath {
     FLOWDEPLOYMENT = "flow/deployments",
     FLOWFUNCTION = "flow/functions",
     FLOWMODULE = "flow/modules",
+    KNOWLEDGE = "knowledge",
     LABEL = "labels",
     NOTIFICATIONENDPOINT = "notification/endpoints",
     NOTIFICATIONRULE = "notification/rules",

package/src/lib/interfaces/resource.interface.js

@@ -14,6 +14,7 @@ var ResourceType;
     ResourceType["FLOWDEPLOYMENT"] = "flowdeployment";
     ResourceType["FLOWFUNCTION"] = "flowfunction";
     ResourceType["FLOWMODULE"] = "flowmodule";
+    ResourceType["KNOWLEDGE"] = "knowledge";
     ResourceType["LABEL"] = "label";
     ResourceType["LOGBOOKENTRY"] = "logbookentry";
     ResourceType["NOTIFICATIONENDPOINT"] = "notificationendpoint";
@@ -37,6 +38,7 @@ var ResourceApiPath;
     ResourceApiPath["FLOWDEPLOYMENT"] = "flow/deployments";
     ResourceApiPath["FLOWFUNCTION"] = "flow/functions";
     ResourceApiPath["FLOWMODULE"] = "flow/modules";
+    ResourceApiPath["KNOWLEDGE"] = "knowledge";
     ResourceApiPath["LABEL"] = "labels";
     ResourceApiPath["NOTIFICATIONENDPOINT"] = "notification/endpoints";
     ResourceApiPath["NOTIFICATIONRULE"] = "notification/rules";
@@ -54,6 +56,7 @@ exports.resourceApiPathToTypeMap = {
     [ResourceApiPath.FLOWDEPLOYMENT]: ResourceType.FLOWDEPLOYMENT,
     [ResourceApiPath.FLOWFUNCTION]: ResourceType.FLOWFUNCTION,
     [ResourceApiPath.FLOWMODULE]: ResourceType.FLOWMODULE,
+    [ResourceApiPath.KNOWLEDGE]: ResourceType.KNOWLEDGE,
     [ResourceApiPath.LABEL]: ResourceType.LABEL,
     [ResourceApiPath.NOTIFICATIONENDPOINT]: ResourceType.NOTIFICATIONENDPOINT,
     [ResourceApiPath.NOTIFICATIONRULE]: ResourceType.NOTIFICATIONRULE,

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

@@ -1,5 +1,5 @@
 import { API } from '../api';
-import { Artifact, Asset, AssetRevision, AssetType, Content, Endpoint, Event, FlowDeployment, FlowDiagram, FlowDto, FlowFunctionDto, FlowFunctionRevision, FlowModule, FlowRevision, Label, LogbookEntry, Notification, ObjectReference, Organization, Secret, Task, TimeSeries, TimeSeriesValue, TimeSeriesValueFeed, Translation, UserSettings, VaultSecret } from '../interfaces';
+import { Artifact, Asset, AssetRevision, AssetType, Content, Endpoint, Event, FlowDeployment, FlowDiagram, FlowDto, FlowFunctionDto, FlowFunctionRevision, FlowModule, FlowRevision, Label, LogbookEntry, Notification, ObjectReference, Organization, Secret, Task, TimeSeries, TimeSeriesValue, TimeSeriesValueFeed, Translation, UserSettings, VaultSecret, type KnowledgePage } from '../interfaces';
 import { AiMockService } from './ai.mock.service';
 import { AlertMockService } from './alert.mock.service';
 import { AssetMockService } from './asset.mock.service';
@@ -16,6 +16,7 @@ import { FlowFunctionsMockService } from './flow-functions.mock.service';
 import { FlowModulesMockService } from './flow-modules.mock.service';
 import { FlowMockService } from './flow.mock.service';
 import { HttpClientMockService } from './http-client.mock.service';
+import { KnowledgeMockService } from './knowledge.mock.service';
 import { LabelMockService } from './label.mock.service';
 import { LogbookMockService } from './logbook.mock.service';
 import { NotificationRulesMockService } from './notification-rules.mock.service';
@@ -31,6 +32,7 @@ import { TimeseriesMockService } from './timeseries.mock.service';
 import { UserMockService } from './user.mock.service';
 import { VaultMockService } from './vault.mock.service';
 export interface MockAPIInitData {
+    knowledge?: KnowledgePage[];
     assets?: AssetInit[];
     assetRevisions?: AssetRevisionInit[];
     contents?: ContentInit[];
@@ -58,6 +60,7 @@ export interface MockAPIInitData {
     translations?: TranslationInit[];
 }
 export declare class MockAPI implements API {
+    knowledge: KnowledgeMockService;
     ai: AiMockService;
     alerts: AlertMockService;
     assets: AssetMockService;

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

@@ -18,6 +18,7 @@ const flow_functions_mock_service_1 = require("./flow-functions.mock.service");
 const flow_modules_mock_service_1 = require("./flow-modules.mock.service");
 const flow_mock_service_1 = require("./flow.mock.service");
 const http_client_mock_service_1 = require("./http-client.mock.service");
+const knowledge_mock_service_1 = require("./knowledge.mock.service");
 const label_mock_service_1 = require("./label.mock.service");
 const logbook_mock_service_1 = require("./logbook.mock.service");
 const notification_rules_mock_service_1 = require("./notification-rules.mock.service");
@@ -35,6 +36,7 @@ const vault_mock_service_1 = require("./vault.mock.service");
 class MockAPI {
     constructor(initData) {
         this.proxy = null;
+        this.knowledge = new knowledge_mock_service_1.KnowledgeMockService(initData.knowledge);
         const { assets = [], assetRevisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], flowRevisions = [], deployments = [], functions = [], functionRevisions = [], modules = [], diagrams = [], labels = [], logbookEntries = [], vault = [], notifications = [], organizations = [], objectReferences = [], timeSeriesValueFeeds = [], resourceSetNames = [], translations = [], } = initData;
         // convert init data to normal data that the services usually use
         const assetTypes = assets

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

@@ -0,0 +1,10 @@
+import { Capability, CapabilityBundle, CapabilityId, Permission, SqlPagination, TokenOption } from '../../interfaces';
+import { APIBaseMock } from '../../mock/api-base.mock';
+import { AuthorizationService } from '../../services/authz/authorization.service';
+export declare class AuthorizationMockService extends APIBaseMock<never> implements AuthorizationService {
+    constructor();
+    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/mock/authz/authorization.mock.service.js

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

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

@@ -1,21 +1,17 @@
 import { AuthzService } from '../../services';
-import { CapabilityBundleService } from '../../services/authz/capability-bundle.service';
-import { CapabilityService } from '../../services/authz/capability.service';
+import { AuthorizationService } from '../../services/authz/authorization.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 authorization: AuthorizationService;
     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

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

@@ -2,8 +2,8 @@ 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']>;
+    getOrgGroupCapabilityBundles(..._args: Parameters<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundles']>): ReturnType<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundles']>;
+    getOrgGroupCapabilityBundle(..._args: Parameters<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundle']>): ReturnType<OrgGroupCapabilityBundleService['getOrgGroupCapabilityBundle']>;
+    createOrgGroupCapabilityBundle(..._args: Parameters<OrgGroupCapabilityBundleService['createOrgGroupCapabilityBundle']>): ReturnType<OrgGroupCapabilityBundleService['createOrgGroupCapabilityBundle']>;
+    deleteOrgGroupCapabilityBundle(..._args: Parameters<OrgGroupCapabilityBundleService['deleteOrgGroupCapabilityBundle']>): ReturnType<OrgGroupCapabilityBundleService['deleteOrgGroupCapabilityBundle']>;
 }

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

@@ -34,3 +34,4 @@ export { UserMockService } from './user.mock.service';
 export { VaultMockService } from './vault.mock.service';
 export { TimeseriesValueFeedManagementMockService } from './timeseries-value-feed-management.mock.service';
 export * from './authz';
+export * from './knowledge.mock.service';

package/src/lib/mock/index.js

@@ -72,3 +72,4 @@ Object.defineProperty(exports, "VaultMockService", { enumerable: true, get: func
 var timeseries_value_feed_management_mock_service_1 = require("./timeseries-value-feed-management.mock.service");
 Object.defineProperty(exports, "TimeseriesValueFeedManagementMockService", { enumerable: true, get: function () { return timeseries_value_feed_management_mock_service_1.TimeseriesValueFeedManagementMockService; } });
 tslib_1.__exportStar(require("./authz"), exports);
+tslib_1.__exportStar(require("./knowledge.mock.service"), exports);

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

@@ -0,0 +1,28 @@
+import { type ConfirmKnowledge, type CreateKnowledge, type KnowledgeBacklinkQuery, type KnowledgeBatch, type KnowledgeHome, type KnowledgeList, type KnowledgePage, type KnowledgeQuery, type KnowledgeRevision, type KnowledgeVersion, type UpdateKnowledge } from '../interfaces';
+import { KnowledgeService } from '../services/knowledge.service';
+export declare class KnowledgeMockService extends KnowledgeService {
+    data: KnowledgePage[];
+    private readonly revisions;
+    constructor(data?: KnowledgePage[]);
+    private remember;
+    /** As in the backend, only changes to these fields create a revision. */
+    private content;
+    private page;
+    private list;
+    addOne(dto: CreateKnowledge): Promise<KnowledgePage>;
+    getOne(id: string): Promise<KnowledgePage>;
+    getMany(query?: KnowledgeQuery): Promise<KnowledgeList>;
+    getHome(query?: KnowledgeQuery): Promise<KnowledgeHome>;
+    getBacklinks(query: KnowledgeBacklinkQuery): Promise<KnowledgeList>;
+    getRelated(id: string, query?: Pick<KnowledgeQuery, 'cursor' | 'limit'>): Promise<KnowledgeList>;
+    getRevision(id: string, revision: number): Promise<KnowledgeRevision>;
+    readBatch(ids: string[]): Promise<KnowledgeBatch>;
+    private check;
+    updateOne(id: string, dto: UpdateKnowledge): Promise<KnowledgePage>;
+    confirm(id: string, dto: ConfirmKnowledge): Promise<KnowledgePage>;
+    withdraw(id: string, dto: KnowledgeVersion): Promise<KnowledgePage>;
+    restore(id: string, dto: KnowledgeVersion): Promise<KnowledgePage>;
+    purgeOrganization(organizationId: string): Promise<{
+        deleted: number;
+    }>;
+}

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeMockService = void 0;
+const interfaces_1 = require("../interfaces");
+const knowledge_service_1 = require("../services/knowledge.service");
+class KnowledgeMockService extends knowledge_service_1.KnowledgeService {
+    constructor(data = []) {
+        super(null);
+        this.data = data;
+        this.revisions = new Map();
+        this.data = structuredClone(data);
+        this.data.forEach((page) => this.remember(page));
+    }
+    remember(page) {
+        this.revisions.set(`${page.id}:${page.revision}`, structuredClone(page));
+    }
+    /** As in the backend, only changes to these fields create a revision. */
+    content(page) {
+        const { title, body, type, description, tags, resource, sources, applicability, links, origin } = page;
+        return JSON.stringify({ title, body, type, description, tags, resource, sources, applicability, links, context: origin.context });
+    }
+    page(id) {
+        const page = this.data.find((item) => item.id === id);
+        if (!page) {
+            throw new Error('Knowledge page not found');
+        }
+        return page;
+    }
+    list(pages, query = {}) {
+        const offset = Number(query.cursor || 0);
+        const active = pages.filter((page) => page.state === 'active');
+        const docs = active.slice(offset, offset + (query.limit || 20)).map(({ body, ...page }) => ({
+            ...structuredClone(page),
+            excerpt: body.slice(0, 300),
+            scope: 'not-evaluated',
+            relations: [],
+            stale: !!page.staleAfter && Date.parse(page.staleAfter) <= Date.now(),
+        }));
+        const more = offset + docs.length < active.length;
+        return { docs, status: more ? 'more' : 'complete', ...(more ? { nextCursor: String(offset + docs.length) } : {}) };
+    }
+    async addOne(dto) {
+        const now = new Date().toISOString();
+        const page = {
+            id: Array.from(globalThis.crypto.getRandomValues(new Uint8Array(12)), (byte) => byte.toString(16).padStart(2, '0')).join(''),
+            title: dto.title,
+            body: dto.body,
+            type: dto.type || 'Maintenance Note',
+            description: dto.description,
+            tags: dto.tags || [],
+            owner: { id: 'mock-org', type: interfaces_1.OwnerType.ORG },
+            createdBy: { id: 'mock-user' },
+            updatedBy: { id: 'mock-user' },
+            createdAt: now,
+            updatedAt: now,
+            origin: { actor: { id: 'mock-user' }, at: now, context: dto.originContext ?? undefined },
+            resource: dto.resource ?? undefined,
+            sources: dto.sources || [],
+            links: (dto.explicitLinks || []).map((target) => ({ target, explicit: true, parsed: false })),
+            applicability: dto.applicability || { mode: 'unknown' },
+            readPermissions: dto.readPermissions || [],
+            readWritePermissions: dto.readWritePermissions || ['mock-org'],
+            state: 'active',
+            revision: 1,
+            recordVersion: 1,
+            confirmations: [],
+            staleAfter: dto.staleAfter || undefined,
+        };
+        this.data.push(page);
+        this.remember(page);
+        return structuredClone(page);
+    }
+    async getOne(id) {
+        return structuredClone(this.page(id));
+    }
+    async getMany(query = {}) {
+        const term = query.query?.toLowerCase();
+        return this.list(this.data.filter((page) => !term || `${page.title} ${page.body}`.toLowerCase().includes(term)), query);
+    }
+    async getHome(query = {}) {
+        return { direct: await this.getMany(query), broader: { docs: [], status: 'complete' }, related: { docs: [], status: 'complete' } };
+    }
+    async getBacklinks(query) {
+        return this.list(this.data.filter((page) => [...page.links, ...page.sources].some((item) => item.target?.resourceType === query.targetType && item.target.id === query.targetId)), query);
+    }
+    async getRelated(id, query = {}) {
+        const page = this.page(id);
+        const outgoing = page.links.filter((link) => link.target.resourceType === interfaces_1.ResourceType.KNOWLEDGE).map((link) => link.target.id);
+        return this.list(this.data.filter((item) => item.id !== id &&
+            (outgoing.includes(item.id) ||
+                item.links.some((link) => link.target.resourceType === interfaces_1.ResourceType.KNOWLEDGE && link.target.id === id))), query);
+    }
+    async getRevision(id, revision) {
+        const current = this.page(id);
+        const page = this.revisions.get(`${id}:${revision}`);
+        if (!page) {
+            throw new Error('Revision not found');
+        }
+        return {
+            page: structuredClone(page),
+            current: { revision: current.revision, recordVersion: current.recordVersion, state: current.state },
+        };
+    }
+    async readBatch(ids) {
+        return {
+            docs: structuredClone(this.data.filter((page) => ids.includes(page.id) && page.state === 'active')),
+            unavailableIds: ids.filter((id) => !this.data.some((page) => page.id === id && page.state === 'active')),
+        };
+    }
+    check(id, version) {
+        const page = this.page(id);
+        if (page.recordVersion !== version) {
+            throw new Error('Version conflict');
+        }
+        return page;
+    }
+    async updateOne(id, dto) {
+        const page = this.check(id, dto.recordVersion);
+        const before = this.content(page);
+        const { explicitLinks, originContext, staleAfter, resource, recordVersion: _version, ...fields } = dto;
+        Object.assign(page, fields);
+        if (resource !== undefined) {
+            page.resource = resource ?? undefined;
+        }
+        if (explicitLinks) {
+            page.links = explicitLinks.map((target) => ({ target, explicit: true, parsed: false }));
+        }
+        if (originContext !== undefined) {
+            page.origin.context = originContext ?? undefined;
+        }
+        if (staleAfter !== undefined) {
+            page.staleAfter = staleAfter || undefined;
+        }
+        if (this.content(page) !== before) {
+            page.revision++;
+            this.remember(page);
+        }
+        page.recordVersion++;
+        return structuredClone(page);
+    }
+    async confirm(id, dto) {
+        const page = this.check(id, dto.recordVersion);
+        if (page.revision !== dto.revision) {
+            throw new Error('Revision conflict');
+        }
+        page.confirmations.push({ actor: { id: 'mock-user' }, at: new Date().toISOString(), revision: page.revision });
+        page.recordVersion++;
+        return structuredClone(page);
+    }
+    async withdraw(id, dto) {
+        const page = this.check(id, dto.recordVersion);
+        page.state = 'withdrawn';
+        page.deletedAt = new Date().toISOString();
+        page.recordVersion++;
+        return structuredClone(page);
+    }
+    async restore(id, dto) {
+        const page = this.check(id, dto.recordVersion);
+        page.state = 'active';
+        delete page.deletedAt;
+        page.recordVersion++;
+        return structuredClone(page);
+    }
+    async purgeOrganization(organizationId) {
+        const kept = this.data.filter((page) => page.owner.id !== organizationId);
+        const deleted = this.data.length - kept.length;
+        this.data = kept;
+        return { deleted };
+    }
+}
+exports.KnowledgeMockService = KnowledgeMockService;