@hahnpro/hpc-api 2026.4.3 → 2026.4.5

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionType = void 0;
+var SubscriptionType;
+(function (SubscriptionType) {
+    SubscriptionType["AZURE"] = "azure";
+    SubscriptionType["DEV"] = "dev";
+    SubscriptionType["FREE"] = "free";
+    SubscriptionType["INACTIVE"] = "inactive";
+    SubscriptionType["PRO"] = "pro";
+    SubscriptionType["UNKNOWN"] = "unknown";
+})(SubscriptionType || (exports.SubscriptionType = SubscriptionType = {}));

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

@@ -0,0 +1,57 @@
+export declare const NatsStreams: {
+    readonly Resource: "resource";
+    readonly Flows: "flows";
+    readonly Audit: "audit";
+};
+export declare const NatsConsumers: {
+    readonly resource: {
+        readonly AttachmentRemover: "attachment-remover";
+        readonly Billing: "billing";
+        readonly ContentAnalyzer: "content-analyzer";
+        readonly ContentIndexer: "content-indexer";
+        readonly ContentDeindexer: "content-deindexer";
+        readonly ContentAnalysis: {
+            readonly AssetsReferencesResolver: "content-analysis-assets-references-resolver";
+            readonly ContentTrashed: "content-trashed";
+            readonly ContentRestored: "content-restored";
+        };
+        readonly EventEmbedding: "event-embedding";
+        readonly FavoriteLabelRemover: "favorite-label-remover";
+        readonly AlertService: {
+            readonly AlertReferencesResolver: "alerts-srv-alert-references-resolver";
+            readonly RuleReferencesResolver: "alerts-srv-rule-references-resolver";
+            readonly TimeSeriesData: "alerts-srv-time-series-data";
+        };
+        readonly CalendarService: {
+            readonly EventReferencesResolver: "calendar-srv-event-references-resolver";
+            readonly TaskReferencesResolver: "calendar-srv-task-references-resolver";
+        };
+        readonly AssetService: {
+            readonly AssetsReferencesResolver: "asset-srv-assets-references-resolver";
+            readonly AssetTypesReferencesResolver: "asset-srv-asset-types-references-resolver";
+        };
+        readonly TimeSeriesService: {
+            readonly AssetsReferencesResolver: "timeseries-srv-assets-references-resolver";
+            readonly TimeSeriesReferencesResolver: "timeseries-srv-timeseries-references-resolver";
+        };
+        readonly ReferenceService: {
+            readonly ReferencedObjectsUpdated: "referenced-objects-updated";
+            readonly ReferenceObjectDeleted: "reference-object-deleted";
+            readonly ReferenceTargetTrashed: "reference-target-trashed";
+            readonly ReferenceTargetRestored: "reference-target-restored";
+            readonly ReferenceCreateCommand: "reference-create-command";
+        };
+    };
+    readonly flows: {
+        readonly FlowDeploymentTrigger: "flow-deployment-trigger";
+        readonly FlowDeploymentDeploy: "flow-deployment-deploy";
+        readonly FlowDeploymentHealth: "flow-deployment-health";
+        readonly FlowDeploymentLogs: "flow-deployment-logs";
+        readonly FlowExecutorEvents: "flow-executor-events";
+    };
+    readonly audit: {
+        readonly AuditLogger: "audit-logger";
+    };
+};
+export declare const natsHpcPrefix = "com.hahnpro";
+export declare const natsFlowsPrefix = "fs";

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.natsFlowsPrefix = exports.natsHpcPrefix = exports.NatsConsumers = exports.NatsStreams = void 0;
+exports.NatsStreams = {
+    Resource: 'resource',
+    Flows: 'flows',
+    Audit: 'audit',
+};
+exports.NatsConsumers = {
+    [exports.NatsStreams.Resource]: {
+        AttachmentRemover: 'attachment-remover',
+        Billing: 'billing',
+        ContentAnalyzer: 'content-analyzer',
+        ContentIndexer: 'content-indexer',
+        ContentDeindexer: 'content-deindexer',
+        ContentAnalysis: {
+            AssetsReferencesResolver: 'content-analysis-assets-references-resolver',
+            ContentTrashed: 'content-trashed',
+            ContentRestored: 'content-restored',
+        },
+        EventEmbedding: 'event-embedding',
+        FavoriteLabelRemover: 'favorite-label-remover',
+        AlertService: {
+            AlertReferencesResolver: 'alerts-srv-alert-references-resolver',
+            RuleReferencesResolver: 'alerts-srv-rule-references-resolver',
+            TimeSeriesData: 'alerts-srv-time-series-data',
+        },
+        CalendarService: {
+            EventReferencesResolver: 'calendar-srv-event-references-resolver',
+            TaskReferencesResolver: 'calendar-srv-task-references-resolver',
+        },
+        AssetService: {
+            AssetsReferencesResolver: 'asset-srv-assets-references-resolver',
+            AssetTypesReferencesResolver: 'asset-srv-asset-types-references-resolver',
+        },
+        TimeSeriesService: {
+            AssetsReferencesResolver: 'timeseries-srv-assets-references-resolver',
+            TimeSeriesReferencesResolver: 'timeseries-srv-timeseries-references-resolver',
+        },
+        ReferenceService: {
+            ReferencedObjectsUpdated: 'referenced-objects-updated',
+            ReferenceObjectDeleted: 'reference-object-deleted',
+            ReferenceTargetTrashed: 'reference-target-trashed',
+            ReferenceTargetRestored: 'reference-target-restored',
+            ReferenceCreateCommand: 'reference-create-command',
+        },
+    },
+    [exports.NatsStreams.Flows]: {
+        FlowDeploymentTrigger: 'flow-deployment-trigger',
+        FlowDeploymentDeploy: 'flow-deployment-deploy',
+        FlowDeploymentHealth: 'flow-deployment-health',
+        FlowDeploymentLogs: 'flow-deployment-logs',
+        FlowExecutorEvents: 'flow-executor-events',
+    },
+    [exports.NatsStreams.Audit]: {
+        AuditLogger: 'audit-logger',
+    },
+};
+exports.natsHpcPrefix = 'com.hahnpro';
+exports.natsFlowsPrefix = 'fs';

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

@@ -73,7 +73,6 @@ export interface UserWithOrgRoles {
     username: string;
     orgRoles: string[];
 }
-export type SubscriptionType = 'dev' | 'free' | 'inactive' | 'pro';
 export declare enum OrganizationMembersInviteOrAdd {
     INVITE = "invite",
     ADD = "add"

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

@@ -16,8 +16,7 @@ export declare enum ObjectReferenceType {
     /**
      * Marks an Object as being part of the 'Weber Engineering - Flange Skill Control' to link the assets
      */
-    FLANGE_SKILL_CONTROL_EXAMINEE_BOOKED_TIME_SLOT_IN_EXAMINATION = "flange_skill_control_examinee_booked_time_slot_in_examination",
-    FLANGE_SKILL_CONTROL_EXAMINATION_BOOKED_TIME_SLOT = "flange_skill_control_examination_booked_time_slot"
+    FLANGE_SKILL_CONTROL_EXAMINEE_BOOKED_TIME_SLOT_IN_EXAMINATION = "flange_skill_control_examinee_booked_time_slot_in_examination"
 }
 export interface ObjectReference {
     id: number;

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

@@ -21,5 +21,4 @@ var ObjectReferenceType;
      * Marks an Object as being part of the 'Weber Engineering - Flange Skill Control' to link the assets
      */
     ObjectReferenceType["FLANGE_SKILL_CONTROL_EXAMINEE_BOOKED_TIME_SLOT_IN_EXAMINATION"] = "flange_skill_control_examinee_booked_time_slot_in_examination";
-    ObjectReferenceType["FLANGE_SKILL_CONTROL_EXAMINATION_BOOKED_TIME_SLOT"] = "flange_skill_control_examination_booked_time_slot";
 })(ObjectReferenceType || (exports.ObjectReferenceType = ObjectReferenceType = {}));

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

@@ -1,4 +1,4 @@
-import type { Api } from './api.interface';
+import type { Api, ObjectIdLike } from './api.interface';
 import { Author } from './author.interface';
 import { Owner } from './owner.interface';
 export declare enum ResourceType {
@@ -39,11 +39,26 @@ export declare enum ResourceApiPath {
     TASK = "tasks"
 }
 export declare const resourceApiPathToTypeMap: Record<ResourceApiPath, ResourceType>;
+export declare enum EventType {
+    CREATED = "created",
+    UPDATED = "updated",
+    DELETED = "deleted",
+    TRASHED = "trashed",
+    RESTORED = "restored"
+}
+export declare enum CommandType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete"
+}
 export interface ResourceReference {
     id: string;
     resourceType: ResourceType;
     dependent?: boolean;
 }
+export type ResolvedResourceReference = ResourceReference & Resource & {
+    id: string;
+};
 export interface Resource {
     id?: string;
     name: string;
@@ -96,3 +111,14 @@ export interface ConnectedResourceItemArray {
 export type ConnectedResourceType = ResourceType.ASSET | ResourceType.ASSETTYPE | ResourceType.CONTENT | ResourceType.NOTIFICATIONENDPOINT | ResourceType.TIMESERIES | ResourceType.FLOW | ResourceType.FLOWMODULE | ResourceType.FLOWFUNCTION | ResourceType.FLOWDEPLOYMENT | ResourceType.EVENT | ResourceType.TASK;
 export type ConnectedResources = Partial<Record<ConnectedResourceType, ConnectedResourceItemArray>>;
 export type SharedResources = Partial<Record<ConnectedResourceType, string[]>>;
+export interface Rollback<T> {
+    doc: T;
+    omitted: Partial<T>;
+}
+export declare function isPopulated<T extends {
+    id?: string;
+}>(value: string | ObjectIdLike | T): value is T;
+export declare function arePopulated<T extends Resource>(value: Array<string | ObjectIdLike | T>): value is T[];
+export type Populated<M, K extends keyof M> = Omit<M, K> & {
+    [P in K]: Exclude<M[P], string | ObjectIdLike>;
+};

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PermissionType = exports.ResourceClass = exports.resourceApiPathToTypeMap = exports.ResourceApiPath = exports.ResourceType = void 0;
+exports.PermissionType = exports.ResourceClass = exports.CommandType = exports.EventType = exports.resourceApiPathToTypeMap = exports.ResourceApiPath = exports.ResourceType = void 0;
+exports.isPopulated = isPopulated;
+exports.arePopulated = arePopulated;
 var ResourceType;
 (function (ResourceType) {
     ResourceType["ALERT"] = "alert";
@@ -57,6 +59,20 @@ exports.resourceApiPathToTypeMap = {
     [ResourceApiPath.TIMESERIES]: ResourceType.TIMESERIES,
     [ResourceApiPath.TASK]: ResourceType.TASK,
 };
+var EventType;
+(function (EventType) {
+    EventType["CREATED"] = "created";
+    EventType["UPDATED"] = "updated";
+    EventType["DELETED"] = "deleted";
+    EventType["TRASHED"] = "trashed";
+    EventType["RESTORED"] = "restored";
+})(EventType || (exports.EventType = EventType = {}));
+var CommandType;
+(function (CommandType) {
+    CommandType["CREATE"] = "create";
+    CommandType["UPDATE"] = "update";
+    CommandType["DELETE"] = "delete";
+})(CommandType || (exports.CommandType = CommandType = {}));
 class ResourceClass {
 }
 exports.ResourceClass = ResourceClass;
@@ -66,3 +82,9 @@ var PermissionType;
     PermissionType["READWRITE"] = "read_write";
     PermissionType["NONE"] = "none";
 })(PermissionType || (exports.PermissionType = PermissionType = {}));
+function isPopulated(value) {
+    return value.id !== undefined && typeof value.id === 'string';
+}
+function arePopulated(value) {
+    return Array.isArray(value) && value.length > 0 && value[0].id !== undefined;
+}

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

@@ -0,0 +1,13 @@
+export interface RoleRepresentation {
+    id?: string;
+    name?: string;
+    description?: string;
+    composite?: boolean;
+    composites?: {
+        realm?: string[];
+        client?: Record<string, string[]>;
+    };
+    clientRole?: boolean;
+    containerId?: string;
+    attributes?: Record<string, string[]>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -7,6 +7,9 @@ export type JsonSchemaType = string | number | boolean | {
     [key: string]: JsonSchemaType;
 } | JsonSchemaArray | null;
 export type JsonSchemaArray = Array<JsonSchemaType>;
+export type JsonSchemaData = {
+    [key: string]: JsonSchemaType;
+};
 export interface JsonSchema {
     default?: JsonSchemaType;
     description?: string;
@@ -15,4 +18,5 @@ export interface JsonSchema {
     required?: boolean | string[];
     title?: string;
     type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+    enum?: (number | string)[];
 }

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

@@ -22,6 +22,10 @@ export interface SearchMatchReasonContentPart {
     text: string;
     isHighlighted: boolean;
 }
+export interface SearchResultItem {
+    id: string;
+    name: string;
+}
 export interface SearchResult<T extends {
     id?: string;
 } = any, K extends keyof T & string = keyof T & string> {

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

@@ -14,10 +14,7 @@ export declare enum TaskStatus {
     ACCEPTED = "ACCEPTED",
     SOLVED = "SOLVED",
     EXPIRED = "EXPIRED",
-    UNKNOWN = "UNKNOWN",
-    IN_PROGRESS = "IN PROGRESS",
-    TODO = "TODO",
-    DONE = "DONE"
+    IN_PROGRESS = "IN PROGRESS"
 }
 export declare enum Priority {
     LOW = "LOW",

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

@@ -14,10 +14,7 @@ var TaskStatus;
     TaskStatus["ACCEPTED"] = "ACCEPTED";
     TaskStatus["SOLVED"] = "SOLVED";
     TaskStatus["EXPIRED"] = "EXPIRED";
-    TaskStatus["UNKNOWN"] = "UNKNOWN";
     TaskStatus["IN_PROGRESS"] = "IN PROGRESS";
-    TaskStatus["TODO"] = "TODO";
-    TaskStatus["DONE"] = "DONE";
 })(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
 var Priority;
 (function (Priority) {

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

@@ -1,5 +1,6 @@
-import { Author } from './author.interface';
-import { Owner } from './owner.interface';
+import type { Change, ChangeSubject } from './api.interface';
+import type { Author } from './author.interface';
+import type { Owner } from './owner.interface';
 export interface TimeSeries {
     id?: string;
     name: string;
@@ -65,3 +66,8 @@ export interface SearchTimeSeriesResult extends Record<string, any> {
 export type TS_GROUPS = 'none' | '10s' | '1m' | '5m' | '15m' | '30m' | '1h' | '3h' | '6h' | '12h' | '1d' | '7d';
 export type Retention = 'always' | '1h' | '3h' | '6h' | '12h' | '24h' | '48h' | '72h' | '7d' | '14d' | '30d' | '90d' | '180d';
 export declare const RETENTION_VALUES: string[];
+export type TimeseriesSubject = ChangeSubject | 'assetRef' | 'maxBucketTimeRange';
+export interface TimeseriesChange extends Change {
+    subject: TimeseriesSubject;
+    value: string;
+}

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

@@ -0,0 +1,14 @@
+export interface Translation {
+    de: TranslationData;
+    en: TranslationData;
+    readPermissions?: string[];
+    readWritePermissions?: string[];
+}
+export interface TranslationData {
+    name?: string;
+    [propertyName: string]: string;
+}
+export declare class TranslationEditData {
+    de: string;
+    en: string;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslationEditData = void 0;
+class TranslationEditData {
+}
+exports.TranslationEditData = TranslationEditData;

package/src/lib/interfaces/type-guards.d.ts

@@ -0,0 +1,17 @@
+import type { Asset } from './asset.interface';
+import type { Author } from './author.interface';
+import type { Content, ContentAnalysis } from './content.interface';
+import { type Event } from './event.interface';
+import { type Owner } from './owner.interface';
+import type { Storage } from './storage.interface';
+import { type Assignee, type LogbookEntry, type Task } from './task.interface';
+export declare function isAuthor(value: unknown): value is Author;
+export declare function isOwner(value: unknown): value is Owner;
+export declare function isStorage(value: unknown): value is Storage;
+export declare function isContentAnalysis(value: unknown): value is ContentAnalysis;
+export declare function isAsset(value: unknown): value is Asset;
+export declare function isContent(value: unknown): value is Content;
+export declare function isEvent(value: unknown): value is Event;
+export declare function isAssignee(value: unknown): value is Assignee;
+export declare function isLogbookEntry(value: unknown): value is LogbookEntry;
+export declare function isTask(value: unknown): value is Task;

package/src/lib/interfaces/type-guards.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthor = isAuthor;
+exports.isOwner = isOwner;
+exports.isStorage = isStorage;
+exports.isContentAnalysis = isContentAnalysis;
+exports.isAsset = isAsset;
+exports.isContent = isContent;
+exports.isEvent = isEvent;
+exports.isAssignee = isAssignee;
+exports.isLogbookEntry = isLogbookEntry;
+exports.isTask = isTask;
+const event_interface_1 = require("./event.interface");
+const owner_interface_1 = require("./owner.interface");
+const task_interface_1 = require("./task.interface");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+const isString = (value) => typeof value === 'string';
+const isNumber = (value) => typeof value === 'number';
+const isDate = (value) => value instanceof Date;
+const isOptional = (value, predicate) => value === undefined || predicate(value);
+const isOptionalString = (value) => isOptional(value, isString);
+const isOptionalNumber = (value) => isOptional(value, isNumber);
+const isOptionalDateOrString = (value) => value === undefined || isDate(value) || isString(value);
+const isArrayOf = (value, predicate) => Array.isArray(value) && value.every(predicate);
+const isOptionalArrayOf = (value, predicate) => value === undefined || isArrayOf(value, predicate);
+const isStringArray = (value) => isArrayOf(value, isString);
+const isOptionalStringArray = (value) => isOptionalArrayOf(value, isString);
+const isOneOf = (value, allowed) => allowed.includes(value);
+const isEnumValue = (target, value) => Object.values(target).includes(value);
+const hasPermissions = (value) => isStringArray(value.readPermissions) && isStringArray(value.readWritePermissions);
+const hasResourceMeta = (value, options) => {
+    const { owner, author, date } = options;
+    if (owner && value.owner !== undefined && !owner(value.owner)) {
+        return false;
+    }
+    if (author && value.createdBy !== undefined && !author(value.createdBy)) {
+        return false;
+    }
+    if (author && value.updatedBy !== undefined && !author(value.updatedBy)) {
+        return false;
+    }
+    if (date && value.createdAt !== undefined && !date(value.createdAt)) {
+        return false;
+    }
+    if (date && value.updatedAt !== undefined && !date(value.updatedAt)) {
+        return false;
+    }
+    if (date && value.deletedAt !== undefined && !date(value.deletedAt)) {
+        return false;
+    }
+    return true;
+};
+function isAuthor(value) {
+    if (!isRecord(value) || !isString(value.id)) {
+        return false;
+    }
+    return isOptionalString(value.username) && isOptionalString(value.impersonatorId) && isOptionalString(value.impersonatorUsername);
+}
+function isOwner(value) {
+    if (!isRecord(value) || !isString(value.id)) {
+        return false;
+    }
+    return isEnumValue(owner_interface_1.OwnerType, value.type) && isOptionalString(value.name);
+}
+function isStorage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (isString(value.id) &&
+        isString(value.filename) &&
+        isString(value.mimetype) &&
+        isNumber(value.size) &&
+        isString(value.createdAt) &&
+        isOneOf(value.provider, [undefined, 's3', 'mongo']) &&
+        isOneOf(value.type, [undefined, 'original', 'preview-sm', 'preview-md', 'preview-lg', 'preview-xl']) &&
+        isOptionalString(value.md5));
+}
+function isContentAnalysis(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (isString(value.id) &&
+        isString(value.contentId) &&
+        isString(value.status) &&
+        isOptionalString(value.error) &&
+        isOptionalString(value.text) &&
+        isOptionalArrayOf(value.pages, (page) => isRecord(page) && isNumber(page.pageNumber) && isOptionalString(page.text)));
+}
+function isAsset(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (isString(value.id) &&
+        isOptionalString(value.translationId) &&
+        isString(value.name) &&
+        isOptionalString(value.description) &&
+        hasPermissions(value) &&
+        isString(value.type) &&
+        isOptionalString(value.type$name) &&
+        isOptionalStringArray(value.tags) &&
+        isOptionalString(value.parent) &&
+        isOptionalString(value.parent$name) &&
+        isOptionalStringArray(value.attachments) &&
+        isOptionalStringArray(value.notificationEndpoints) &&
+        isOptionalStringArray(value.aliases) &&
+        isOptional(value.data, isRecord) &&
+        isOptional(value.timeseries, isRecord) &&
+        isOptional(value.event, isRecord) &&
+        hasResourceMeta(value, { owner: isOwner, author: isAuthor }));
+}
+function isContent(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const hasValidAnalysis = value.analysis === undefined || isString(value.analysis) || isContentAnalysis(value.analysis);
+    return (isOptionalString(value.id) &&
+        isString(value.fileId) &&
+        isString(value.filename) &&
+        isOptionalString(value.description) &&
+        isString(value.mimetype) &&
+        isNumber(value.size) &&
+        hasPermissions(value) &&
+        isOptionalStringArray(value.tags) &&
+        isOptionalStringArray(value.assets) &&
+        isOptionalArrayOf(value.files, isStorage) &&
+        hasResourceMeta(value, { owner: isOwner, author: isAuthor, date: isString }) &&
+        hasValidAnalysis);
+}
+function isEvent(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (isOptionalString(value.id) &&
+        isString(value.name) &&
+        isOptionalString(value.description) &&
+        isOptionalStringArray(value.tags) &&
+        hasPermissions(value) &&
+        isEnumValue(event_interface_1.EventLevel, value.level) &&
+        isOptional(value.data, isRecord) &&
+        isOptionalString(value.assetRef) &&
+        isOptionalString(value.assetRef$name) &&
+        isOptionalString(value.alertRef) &&
+        isOptionalString(value.tsRef) &&
+        isOptionalString(value.eventRef) &&
+        isOptionalString(value.cause) &&
+        isOptionalString(value.group) &&
+        hasResourceMeta(value, { owner: isOwner, author: isAuthor, date: isString }));
+}
+function isAssignee(value) {
+    return isRecord(value) && isString(value.id) && isEnumValue(task_interface_1.AssigneeType, value.type);
+}
+function isLogbookEntry(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (isString(value.taskId) &&
+        isString(value.date) &&
+        isNumber(value.duration) &&
+        isOneOf(value.source, ['manual', 'voice', 'automatic']) &&
+        isOptionalString(value.id) &&
+        isOptionalString(value.comment) &&
+        isOptionalString(value.createdAt) &&
+        isOptionalString(value.updatedAt) &&
+        isOptionalArrayOf(value.materials, (material) => isRecord(material) && isString(material.name) && isNumber(material.quantity)) &&
+        isOptional(value.data, isRecord) &&
+        isOptional(value.createdBy, isAuthor));
+}
+function isTask(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const hasValidStatusHistory = value.statusHistoryLog === undefined ||
+        (Array.isArray(value.statusHistoryLog) && value.statusHistoryLog.every((status) => isEnumValue(task_interface_1.TaskStatus, status)));
+    return (isOptionalString(value.id) &&
+        isOptionalDateOrString(value.createdAt) &&
+        isOptionalDateOrString(value.updatedAt) &&
+        isOptionalDateOrString(value.deletedAt) &&
+        isOptionalNumber(value.revision) &&
+        hasResourceMeta(value, { owner: isOwner, author: isAuthor, date: (candidate) => isString(candidate) || candidate instanceof Date }) &&
+        isString(value.name) &&
+        isOptionalString(value.description) &&
+        isEnumValue(task_interface_1.Priority, value.priority) &&
+        isOptionalStringArray(value.tags) &&
+        hasPermissions(value) &&
+        isOptionalString(value.assetRef) &&
+        isOptionalString(value.assetRef$name) &&
+        isOptionalString(value.eventRef) &&
+        isOptionalString(value.eventRef$name) &&
+        isOptionalNumber(value.gitHubNr) &&
+        isOptionalString(value.schedule) &&
+        (value.expiryDate === undefined || value.expiryDate instanceof Date) &&
+        isOptionalString(value.parent) &&
+        isOptionalString(value.parent$name) &&
+        isOptionalStringArray(value.subTasks) &&
+        isArrayOf(value.assignedTo, isAssignee) &&
+        isOptionalString(value.acceptedBy) &&
+        (value.status === undefined || isEnumValue(task_interface_1.TaskStatus, value.status)) &&
+        hasValidStatusHistory &&
+        isOptionalString(value.reason) &&
+        isOptionalString(value.logbookSchema));
+}

package/src/lib/interfaces/user-settings.interface.d.ts

@@ -1,16 +1,16 @@
 import { Api } from './api.interface';
 export interface UserSettings extends Api {
     activeOrg?: string;
-    activeTags: string[];
-    applications: Application[];
+    activeTags?: string[];
+    applications?: Application[];
     consent?: Consent;
-    creationReadRoles: Permission[];
-    creationWriteRoles: Permission[];
-    deletionRequested: boolean;
-    favoriteLabelsOrder: Record<string, number>;
-    language: string;
-    tableSettings: TableSetting[];
-    userId: string;
+    creationReadRoles?: Permission[];
+    creationWriteRoles?: Permission[];
+    deletionRequested?: boolean;
+    favoriteLabelsOrder?: Record<string, number>;
+    language?: string;
+    tableSettings?: TableSetting[];
+    userId?: string;
 }
 export interface Consent {
     essential?: boolean;
@@ -27,7 +27,12 @@ export interface Permission {
 }
 export interface TableSettingProfile {
     name: string;
-    cols: string;
+    isTranslationKey?: boolean;
+    cols?: Record<string, string> | string;
+    filter?: string;
+    sort?: string;
+    assetSupertypeFilter?: string;
+    errorTime?: number;
 }
 export interface TableSetting {
     name: string;

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

@@ -1,5 +1,14 @@
 import { Author } from './author.interface';
 import { Owner } from './owner.interface';
+export declare enum SecretType {
+    KV = "KV",
+    OAuth2 = "OAuth2"
+}
+export interface KVSecretVersion {
+    version: number;
+    isCurrent: boolean;
+    createdAt: string;
+}
 export interface VaultSecret {
     id?: string;
     name: string;
@@ -12,4 +21,6 @@ export interface VaultSecret {
     createdBy?: Author;
     updatedBy?: Author;
     updatedAt?: string;
+    secretType?: SecretType;
+    expiryDate?: string;
 }

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

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretType = void 0;
+var SecretType;
+(function (SecretType) {
+    SecretType["KV"] = "KV";
+    SecretType["OAuth2"] = "OAuth2";
+})(SecretType || (exports.SecretType = SecretType = {}));