@hahnpro/hpc-api 2026.9.10 → 2026.9.11

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @hahnpro/hpc-api
 
+# 2026.9.11
+
+- Added `api.knowledge` client, shared types and mock support for pages, revisions, discovery and lifecycle operations #5262
+
 # 2026.9.10
 
 - Updated AI interface and added limit to `getValuesOfPeriod` of timeseries service

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2026.9.10",
+  "version": "2026.9.11",
   "description": "Module for easy access to the HahnPRO Cloud API",
   "license": "MIT",
   "author": {

package/src/lib/api.d.ts

@@ -1,6 +1,6 @@
 import type { TimeSeriesValueFeedManagementApi } from './interfaces';
 import { QueueOptions } from './queue';
-import { AiService, AlertService, AssetService, AssetTypesService, AuthzService, ContentService, CrmService, DataspaceService, EndpointService, EventService, FlangeSkillControlService, FlowDeploymentService, FlowFunctionService, FlowModuleService, FlowService, HttpClientService, LabelService, LogbookService, NotificationRuleService, NotificationService, ObjectReferenceService, OrganizationsAdministrationService, OrganizationsResourcesService, OrganizationsService, ProxyService, SearchService, TaskService, TimeSeriesService, UserService, VaultService } from './services';
+import { AiService, AlertService, AssetService, AssetTypesService, AuthzService, ContentService, CrmService, DataspaceService, EndpointService, EventService, FlangeSkillControlService, FlowDeploymentService, FlowFunctionService, FlowModuleService, FlowService, HttpClientService, KnowledgeService, LabelService, LogbookService, NotificationRuleService, NotificationService, ObjectReferenceService, OrganizationsAdministrationService, OrganizationsResourcesService, OrganizationsService, ProxyService, SearchService, TaskService, TimeSeriesService, UserService, VaultService } from './services';
 export declare class API {
     readonly httpClient?: HttpClientService;
     ai: AiService;
@@ -18,6 +18,7 @@ export declare class API {
     flowDeployments: FlowDeploymentService;
     flowFunctions: FlowFunctionService;
     flowModules: FlowModuleService;
+    knowledge: KnowledgeService;
     labels: LabelService;
     logbook: LogbookService;
     objectReferences: ObjectReferenceService;

package/src/lib/api.js

@@ -49,6 +49,7 @@ class API {
         this.flowDeployments = new services_1.FlowDeploymentService(this.httpClient);
         this.flowFunctions = new services_1.FlowFunctionService(this.httpClient);
         this.flowModules = new services_1.FlowModuleService(this.httpClient);
+        this.knowledge = new services_1.KnowledgeService(this.httpClient);
         this.labels = new services_1.LabelService(this.httpClient);
         this.logbook = new services_1.LogbookService(this.httpClient);
         this.objectReferences = new services_1.ObjectReferenceService(this.httpClient);

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

@@ -77,3 +77,4 @@ export { WebSocketMessageType } from './websockets.interface';
 export type { AiThreadListChangedEvent, WebSocketError } from './websockets.interface';
 export * from './authz';
 export * from './crm-autonomy.interface';
+export * from './knowledge.interface';

package/src/lib/interfaces/index.js

@@ -123,3 +123,4 @@ var websockets_interface_1 = require("./websockets.interface");
 Object.defineProperty(exports, "WebSocketMessageType", { enumerable: true, get: function () { return websockets_interface_1.WebSocketMessageType; } });
 tslib_1.__exportStar(require("./authz"), exports);
 tslib_1.__exportStar(require("./crm-autonomy.interface"), exports);
+tslib_1.__exportStar(require("./knowledge.interface"), exports);

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

@@ -0,0 +1,142 @@
+import type { Author } from './author.interface';
+import type { Owner } from './owner.interface';
+import { ResourceType } from './resource.interface';
+export declare const KNOWLEDGE_TARGET_TYPES: readonly [ResourceType.KNOWLEDGE, ResourceType.ASSET, ResourceType.ASSETTYPE, ResourceType.CONTENT, ResourceType.EVENT, ResourceType.TASK];
+export interface KnowledgeTarget {
+    resourceType: (typeof KNOWLEDGE_TARGET_TYPES)[number];
+    id: string;
+}
+export interface KnowledgeSource {
+    id: string;
+    kind: 'observation' | 'resource' | 'external';
+    target?: KnowledgeTarget;
+    text?: string;
+    url?: string;
+    version?: string;
+    locator?: string;
+    /** False means the target was not readable at response time. */
+    available?: boolean;
+}
+export interface KnowledgeLink {
+    target: KnowledgeTarget;
+    explicit: boolean;
+    parsed: boolean;
+}
+export type KnowledgeApplicability = {
+    mode: 'unknown' | 'organization';
+} | {
+    mode: 'assets';
+    assetIds: string[];
+} | {
+    mode: 'subtree';
+    rootId: string;
+    assetTypeId?: string;
+} | {
+    mode: 'assetType';
+    assetTypeId: string;
+};
+export interface KnowledgeConfirmation {
+    actor: Author;
+    at: string;
+    revision: number;
+}
+export interface KnowledgePage {
+    id: string;
+    owner: Owner;
+    title: string;
+    body: string;
+    type: string;
+    description?: string;
+    tags: string[];
+    resource?: KnowledgeTarget;
+    origin: {
+        actor: Author;
+        at: string;
+        context?: KnowledgeTarget;
+    };
+    sources: KnowledgeSource[];
+    links: KnowledgeLink[];
+    applicability: KnowledgeApplicability;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    state: 'active' | 'withdrawn';
+    staleAfter?: string;
+    confirmations: KnowledgeConfirmation[];
+    revision: number;
+    recordVersion: number;
+    createdBy: Author;
+    updatedBy: Author;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+}
+export interface CreateKnowledge {
+    title: string;
+    body: string;
+    type?: string;
+    description?: string;
+    tags?: string[];
+    /** `null` clears the value on update. */
+    resource?: KnowledgeTarget | null;
+    /** `null` clears the value on update. */
+    originContext?: KnowledgeTarget | null;
+    sources?: Omit<KnowledgeSource, 'available'>[];
+    explicitLinks?: KnowledgeTarget[];
+    applicability?: KnowledgeApplicability;
+    readPermissions?: string[];
+    readWritePermissions?: string[];
+    staleAfter?: string | null;
+}
+export type UpdateKnowledge = Partial<CreateKnowledge> & {
+    recordVersion: number;
+};
+export interface KnowledgeVersion {
+    recordVersion: number;
+}
+export interface ConfirmKnowledge extends KnowledgeVersion {
+    revision: number;
+}
+export type KnowledgeRelation = 'OBSERVED_IN' | 'EVIDENCED_BY' | 'RELATED_TO' | 'APPLIES_TO';
+export type KnowledgeScopeResult = 'matches' | 'not-established' | 'not-evaluated';
+export interface KnowledgeQuery {
+    group?: 'direct' | 'broader' | 'related';
+    query?: string;
+    contextType?: 'asset' | 'location' | 'organization';
+    contextId?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface KnowledgeBacklinkQuery {
+    targetType: KnowledgeTarget['resourceType'];
+    targetId: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface KnowledgePreview extends Omit<KnowledgePage, 'body'> {
+    excerpt: string;
+    scope: KnowledgeScopeResult;
+    relations: KnowledgeRelation[];
+    stale: boolean;
+}
+export interface KnowledgeList {
+    docs: KnowledgePreview[];
+    nextCursor?: string;
+    status: 'complete' | 'more' | 'incomplete' | 'unavailable';
+}
+export interface KnowledgeHome {
+    direct: KnowledgeList;
+    broader: KnowledgeList;
+    related: KnowledgeList;
+}
+export interface KnowledgeBatch {
+    docs: KnowledgePage[];
+    unavailableIds: string[];
+}
+export interface KnowledgeRevision {
+    page: KnowledgePage;
+    current: {
+        revision: number;
+        recordVersion: number;
+        state: KnowledgePage['state'];
+    };
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWLEDGE_TARGET_TYPES = void 0;
+const resource_interface_1 = require("./resource.interface");
+exports.KNOWLEDGE_TARGET_TYPES = [
+    resource_interface_1.ResourceType.KNOWLEDGE,
+    resource_interface_1.ResourceType.ASSET,
+    resource_interface_1.ResourceType.ASSETTYPE,
+    resource_interface_1.ResourceType.CONTENT,
+    resource_interface_1.ResourceType.EVENT,
+    resource_interface_1.ResourceType.TASK,
+];

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/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;

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;