@hahnpro/hpc-api 2025.3.3 → 2025.3.6

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @hahnpro/hpc-api
 
+## 2025.3.4
+
+Added `addOrganizationMembers`, `addSubscriptionToOrganization` and `getOrganizationIdByName` methods to Organizations API service
+
 ## 2025.3.3
 
 ### Patch Changes

package/package.json

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

package/src/index.d.ts

@@ -8,10 +8,11 @@ export * from './lib/flow.interface';
 export * from './lib/flow-deployment.interface';
 export * from './lib/flow-function.interface';
 export * from './lib/http.service';
-export * from './lib/label.interface';
 export * from './lib/mock';
 export * from './lib/notification.interface';
+export * from './lib/organization.interface';
 export * from './lib/schema.interface';
 export * from './lib/secret.interface';
 export * from './lib/task.interface';
 export * from './lib/vault.interface';
+export * from './lib/task.service';

package/src/index.js

@@ -10,10 +10,11 @@ tslib_1.__exportStar(require("./lib/flow.interface"), exports);
 tslib_1.__exportStar(require("./lib/flow-deployment.interface"), exports);
 tslib_1.__exportStar(require("./lib/flow-function.interface"), exports);
 tslib_1.__exportStar(require("./lib/http.service"), exports);
-tslib_1.__exportStar(require("./lib/label.interface"), exports);
 tslib_1.__exportStar(require("./lib/mock"), exports);
 tslib_1.__exportStar(require("./lib/notification.interface"), exports);
+tslib_1.__exportStar(require("./lib/organization.interface"), exports);
 tslib_1.__exportStar(require("./lib/schema.interface"), exports);
 tslib_1.__exportStar(require("./lib/secret.interface"), exports);
 tslib_1.__exportStar(require("./lib/task.interface"), exports);
 tslib_1.__exportStar(require("./lib/vault.interface"), exports);
+tslib_1.__exportStar(require("./lib/task.service"), exports);

package/src/lib/api.d.ts

@@ -6,13 +6,12 @@ import { FlowFunctionService } from './flow-function.service';
 import { FlowModuleService } from './flow-module.service';
 import { FlowService } from './flow.service';
 import { HttpClient } from './http.service';
-import { LabelService } from './label.service';
 import { NotificationRuleService } from './notification-rule.service';
 import { NotificationService } from './notification.service';
 import { OrganizationService } from './organization.service';
 import { ProxyService } from './proxy.service';
 import { SecretService } from './secret.service';
-import { AiService, AssetService, AssetTypesService, EventService, TimeSeriesService } from './services';
+import { AiService, AssetService, AssetTypesService, EventService, LabelService, TimeSeriesService } from './services';
 import { TaskService } from './task.service';
 import { UserService } from './user.service';
 import { VaultService } from './vault.service';

package/src/lib/api.js

@@ -9,7 +9,6 @@ const flow_function_service_1 = require("./flow-function.service");
 const flow_module_service_1 = require("./flow-module.service");
 const flow_service_1 = require("./flow.service");
 const http_service_1 = require("./http.service");
-const label_service_1 = require("./label.service");
 const notification_rule_service_1 = require("./notification-rule.service");
 const notification_service_1 = require("./notification.service");
 const organization_service_1 = require("./organization.service");
@@ -53,7 +52,7 @@ class API {
         this.flowDeployments = new flow_deployment_service_1.FlowDeploymentService(this.httpClient);
         this.flowFunctions = new flow_function_service_1.FlowFunctionService(this.httpClient);
         this.flowModules = new flow_module_service_1.FlowModuleService(this.httpClient);
-        this.labels = new label_service_1.LabelService(this.httpClient);
+        this.labels = new services_1.LabelService(this.httpClient);
         this.organizations = new organization_service_1.OrganizationService(this.httpClient);
         this.proxy = new proxy_service_1.ProxyService(this.httpClient);
         this.secrets = new secret_service_1.SecretService(this.httpClient);

package/src/lib/data.service.d.ts

@@ -23,5 +23,5 @@ export declare class DataService<T> extends APIBase implements DataInterface<T>
         [key: string]: any;
     }): Promise<T>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
-    private getFilterString;
+    protected getFilterString(filter: Filter): string;
 }

package/src/lib/http.service.d.ts

@@ -35,6 +35,7 @@ export declare class HttpClient {
     get: <T>(url: string, config?: Config) => Promise<T>;
     post: <T>(url: string, data: any, config?: Config) => Promise<T>;
     put: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    patch: <T>(url: string, data: any, config?: Config) => Promise<T>;
     protected request: <T>(method: Method, url: string, config?: Config, data?: any) => Promise<T>;
     addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
     destroyEventSource(id: string): void;

package/src/lib/http.service.js

@@ -22,6 +22,7 @@ class HttpClient {
         this.get = (url, config) => this.request('GET', url, config);
         this.post = (url, data, config) => this.request('POST', url, config, data);
         this.put = (url, data, config) => this.request('PUT', url, config, data);
+        this.patch = (url, data, config) => this.request('PATCH', url, config, data);
         this.request = (method, url, config = {}, data) => {
             return this.requestQueue.add(() => new Promise((resolve, reject) => {
                 const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();

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

@@ -2,4 +2,6 @@ export type { Resource, ResourceReference, Owner, OwnerType, Author } from './re
 export type { AiAssistant, AssistantMessage, Message, SpeechToken, SystemMessage, Thread, ThreadPopulated, ToolMessage, UserMessage, } from './ai.interface';
 export type { Action, ActionRevision, Asset, AssetRevision, AssetType, AssetTypeRevision, Attachment, EventCause, EventLevelOverride, Template, } from './asset.interface';
 export type { Event, EventLevel, CreateEventDto } from './event.interface';
+export type { Label, CreateLabelDto, UpdateLabelDto } from './label.interface';
 export type { TimeSeries, TimeSeriesBucket, TimeSeriesCondition, TimeSeriesValue, TS_GROUPS } from './timeseries.interface';
+export type { SearchOptions, SearchResult, SearchSortOption, SortableField } from './search.interface';

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

@@ -0,0 +1,16 @@
+import { Author, Owner } from './resource.interface';
+export interface Label {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    readPermissions?: string[];
+    readWritePermissions: string[];
+    owner: Owner;
+    createdBy: Author;
+    updatedBy: Author;
+    createdAt: string;
+    updatedAt: string;
+}
+export type CreateLabelDto = Pick<Label, 'name' | 'description' | 'color' | 'readPermissions' | 'readWritePermissions'>;
+export type UpdateLabelDto = Partial<CreateLabelDto>;

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

@@ -0,0 +1,24 @@
+export interface SearchOptions<T extends {
+    id?: string;
+}, K extends keyof T & string = keyof T & string> {
+    query: string;
+    sort?: SearchSortOption<T>[];
+    limit?: number;
+    offset?: number;
+    trackTotal?: boolean;
+    resultFields?: K[];
+    searchFields?: string[];
+}
+export type SortableField<T> = keyof T | `${keyof T & string}.keyword`;
+export interface SearchSortOption<T> {
+    field: SortableField<T>;
+    order: 'asc' | 'desc';
+}
+export interface SearchResult<T extends {
+    id?: string;
+} = any, K extends keyof T & string = keyof T & string> {
+    docs: Pick<T, K | 'id'>[];
+    limit: number;
+    offset: number;
+    total: number;
+}

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

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

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

@@ -10,8 +10,7 @@ import { FlowModule } from '../flow-module.interface';
 import { FlowModuleService } from '../flow-module.service';
 import { FlowDiagram, FlowDto, FlowRevision } from '../flow.interface';
 import { FlowService } from '../flow.service';
-import { Asset, AssetRevision, AssetType, Event, TimeSeries, TimeSeriesValue } from '../interfaces';
-import { Label } from '../label.interface';
+import { Asset, AssetRevision, AssetType, Event, Label, TimeSeries, TimeSeriesValue } from '../interfaces';
 import { NotificationRuleService } from '../notification-rule.service';
 import { Notification } from '../notification.interface';
 import { Organization } from '../organization.interface';

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

@@ -168,6 +168,11 @@ class MockAPI {
             description: v.description ?? '',
             readPermissions: v.readPermissions ?? [],
             readWritePermissions: v.readWritePermissions ?? [],
+            owner: v.owner ?? { id: '123', type: 'org' },
+            createdBy: v.createdBy ?? { id: '123', username: 'test-user' },
+            updatedBy: v.updatedBy ?? { id: '123', username: 'test-user' },
+            createdAt: v.createdAt ?? new Date().toISOString(),
+            updatedAt: v.updatedAt ?? new Date().toISOString(),
         }));
         const vaultSecrets1 = vault.map((v) => ({
             ...v,

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

@@ -1,5 +1,5 @@
 import FormData from 'form-data';
-import { Paginated, RequestParameter } from '../data.interface';
+import { Filter, Paginated, RequestParameter } from '../data.interface';
 import { TokenOption } from '../http.service';
 import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from '../interfaces';
 import { AssetService } from '../services';
@@ -17,6 +17,7 @@ export declare class AssetMockService extends BaseService implements AssetServic
     constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);
     private getAssets;
     addOne(dto: Asset): Promise<Asset>;
+    count(filter: Filter, options?: TokenOption): Promise<number>;
     deleteOne(assetId: string, force?: boolean): Promise<Asset>;
     getMany(params?: RequestParameter): Promise<Paginated<Asset[]>>;
     updateOne(assetId: string, dto: Asset): Promise<Asset>;
@@ -30,5 +31,6 @@ export declare class AssetMockService extends BaseService implements AssetServic
     deleteRevision(assetId: string, revisionId: string): Promise<any>;
     findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
     updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Asset[]>>;
 }
 export {};

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

@@ -30,6 +30,9 @@ class AssetMockService extends BaseService {
         this.revisions.push({ ...dto, originalId: dto.id });
         return super.addOne(dto);
     }
+    count(filter, options = {}) {
+        return Promise.resolve(this.data.length);
+    }
     deleteOne(assetId, force = false) {
         const asset = this.data.find((v) => v.id === assetId);
         if (!asset?.deletedAt && !force) {
@@ -120,5 +123,13 @@ class AssetMockService extends BaseService {
         this.data[index] = { ...asset, ...dto };
         return Promise.resolve(this.data[index]);
     }
+    findByName(name, options = {}) {
+        const docs = this.data.filter((asset) => asset.name === name);
+        return Promise.resolve({
+            docs,
+            total: docs.length,
+            limit: Number.MAX_SAFE_INTEGER,
+        });
+    }
 }
 exports.AssetMockService = AssetMockService;

package/src/lib/mock/flow-deployment.mock.service.js

@@ -112,8 +112,9 @@ class FlowDeploymentMockService extends BaseService {
     async getReferences(properties) {
         // super simplified version of real resolver
         return Promise.all(Object.keys(properties).map(async (prop) => {
-            if (prop !== 'assetId')
+            if (prop !== 'assetId') {
                 throw new Error('not implemented');
+            }
             return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
         }));
     }

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

@@ -1,8 +1,9 @@
-import { Label } from '../label.interface';
-import { LabelService } from '../label.service';
+import type { Label, SearchOptions, SearchResult } from '../interfaces';
+import { LabelService } from '../services/label.service';
 import { DataMockService } from './data.mock.service';
 export declare class LabelMockService extends DataMockService<Label> implements LabelService {
     constructor(labels: Label[]);
     count(): Promise<number>;
     getOneByName(name: string): Promise<Label>;
+    search(query: SearchOptions<Label>, _: any): Promise<SearchResult<Label>>;
 }

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

@@ -13,5 +13,14 @@ class LabelMockService extends data_mock_service_1.DataMockService {
     getOneByName(name) {
         return Promise.resolve(this.data.find((label) => label.name === name));
     }
+    search(query, _) {
+        const docs = this.data.filter((label) => label.name.includes(query.query));
+        return Promise.resolve({
+            docs,
+            limit: query.limit,
+            offset: query.offset,
+            total: docs.length,
+        });
+    }
 }
 exports.LabelMockService = LabelMockService;

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

@@ -1,7 +1,10 @@
-import { Organization } from '../organization.interface';
+import { Organization, OrganizationName, SubscriptionType, UserWithOrgRoles } from '../organization.interface';
 import { OrganizationService } from '../organization.service';
 import { DataMockService } from './data.mock.service';
 export declare class OrganizationMockService extends DataMockService<Organization> implements OrganizationService {
     constructor(organizations: Organization[]);
     addOrganizationInvitation(id: string, email: string, roles: string[]): Promise<void>;
+    addOrganizationMembers(id: string, usersWithOrgRoles: UserWithOrgRoles[]): Promise<void>;
+    addSubscriptionToOrganization(id: string, type: SubscriptionType): Promise<Organization>;
+    getOrganizationIdByName(name: string): Promise<OrganizationName>;
 }

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

@@ -9,9 +9,36 @@ class OrganizationMockService extends data_mock_service_1.DataMockService {
     }
     addOrganizationInvitation(id, email, roles) {
         if (!id || !email || !roles?.length) {
-            return Promise.reject();
+            return Promise.reject('Bad Request');
         }
         return Promise.resolve();
     }
+    addOrganizationMembers(id, usersWithOrgRoles) {
+        if (!id ||
+            !usersWithOrgRoles?.length ||
+            usersWithOrgRoles.some((userWithOrgRoles) => !userWithOrgRoles.username || !userWithOrgRoles.orgRoles?.length)) {
+            return Promise.reject('Bad Request');
+        }
+        return Promise.resolve();
+    }
+    addSubscriptionToOrganization(id, type) {
+        if (!id || !type) {
+            return Promise.reject('Bad Request');
+        }
+        const organization = this.data.find((org) => org.id === id);
+        if (!organization) {
+            return Promise.reject('Not Found');
+        }
+        const existingId = organization.subscriptionId;
+        if (existingId) {
+            organization.previousSubscriptions = [existingId, ...(organization.previousSubscriptions || [])];
+        }
+        organization.subscriptionId = `test-subscription-${organization.previousSubscriptions?.length || 0}`;
+        return Promise.resolve(organization);
+    }
+    getOrganizationIdByName(name) {
+        const id = this.data.find((org) => org.name === name)?.id;
+        return Promise.resolve({ id });
+    }
 }
 exports.OrganizationMockService = OrganizationMockService;

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

@@ -1,5 +1,6 @@
 import { Paginated, RequestParameter } from '../data.interface';
-import { Task } from '../task.interface';
+import { TokenOption } from '../http.service';
+import { LogbookEntry, LogbookEntryDto, Task } from '../task.interface';
 import { TaskService } from '../task.service';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
@@ -9,9 +10,21 @@ interface BaseService extends DataMockService<Task>, TrashMockService<Task> {
 declare class BaseService extends APIBaseMock<Task> {
 }
 export declare class TaskMockService extends BaseService implements TaskService {
-    constructor(tasks: Task[]);
+    private entries;
+    constructor(tasks: Task[], logbookEntries?: LogbookEntry[]);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
     deleteOne(taskId: string, force?: boolean): Promise<Task>;
     getMany(params?: RequestParameter): Promise<Paginated<Task[]>>;
+    findByName(name: string, options?: any): Promise<Paginated<Task[]>>;
+    findByAsset(assetId: string, options?: any): Promise<Paginated<Task[]>>;
+    getLogbookEntries(taskId: string, limit?: number, offset?: number, _options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
+    addLogbookEntry(taskId: string, dto: LogbookEntryDto, _options?: TokenOption): Promise<LogbookEntry>;
+    updateLogbookEntry(taskId: string, entryId: string, dto: Partial<LogbookEntryDto>, _options?: TokenOption): Promise<LogbookEntry>;
+    deleteLogbookEntry(taskId: string, entryId: string, _options?: TokenOption): Promise<{
+        deleted: boolean;
+    }>;
+    getUserLogbookEntries(limit?: number, offset?: number, _options?: TokenOption, userId?: string): Promise<Paginated<LogbookEntry[]>>;
+    seed(entries: LogbookEntry[]): void;
+    clear(): void;
 }
 export {};

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

@@ -12,8 +12,10 @@ BaseService = tslib_1.__decorate([
     (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
 ], BaseService);
 class TaskMockService extends BaseService {
-    constructor(tasks) {
+    constructor(tasks, logbookEntries = []) {
         super(tasks);
+        this.entries = [];
+        this.entries = [...logbookEntries];
     }
     async createTaskAttachedToAsset(dto) {
         this.data.push(dto);
@@ -32,5 +34,94 @@ class TaskMockService extends BaseService {
         const page = this.getItems(params, false);
         return Promise.resolve(page);
     }
+    findByName(name, options = {}) {
+        const filtered = this.data.filter((task) => task.name === name);
+        const result = {
+            docs: filtered,
+            total: filtered.length,
+            page: 1,
+            limit: filtered.length,
+        };
+        return Promise.resolve(result);
+    }
+    findByAsset(assetId, options = {}) {
+        const filtered = this.data.filter((task) => task.assetRef === assetId);
+        const result = {
+            docs: filtered,
+            total: filtered.length,
+            page: 1,
+            limit: filtered.length,
+        };
+        return Promise.resolve(result);
+    }
+    // override network methods to in‑memory versions
+    async getLogbookEntries(taskId, limit = 50, offset = 0, _options = {}) {
+        const taskEntries = this.entries.filter((e) => e.taskId === taskId);
+        const docs = taskEntries.slice(offset, offset + limit);
+        return {
+            docs,
+            limit,
+            offset,
+            total: taskEntries.length,
+            page: Math.floor(offset / limit) + 1,
+            pages: Math.max(1, Math.ceil(taskEntries.length / limit)),
+        };
+    }
+    async addLogbookEntry(taskId, dto, _options = {}) {
+        const id = globalThis.crypto?.randomUUID?.() || Math.random().toString(36).slice(2);
+        const now = new Date().toISOString();
+        const entry = {
+            id,
+            taskId,
+            date: dto.date || now,
+            duration: dto.duration ?? 0,
+            materials: dto.materials || [],
+            comment: dto.comment || '',
+            source: 'manual',
+            createdAt: now,
+            updatedAt: now,
+            createdBy: dto.createdBy || { id: 'mock-user', username: 'mock-user' },
+        };
+        this.entries.push(entry);
+        return entry;
+    }
+    async updateLogbookEntry(taskId, entryId, dto, _options = {}) {
+        const idx = this.entries.findIndex((e) => e.id === entryId && e.taskId === taskId);
+        if (idx === -1) {
+            throw new Error('Not found');
+        }
+        const updated = {
+            ...this.entries[idx],
+            ...dto,
+            materials: dto.materials !== undefined ? dto.materials : this.entries[idx].materials,
+            updatedAt: new Date().toISOString(),
+        };
+        this.entries[idx] = updated;
+        return updated;
+    }
+    async deleteLogbookEntry(taskId, entryId, _options = {}) {
+        const before = this.entries.length;
+        this.entries = this.entries.filter((e) => !(e.id === entryId && e.taskId === taskId));
+        return { deleted: this.entries.length < before };
+    }
+    async getUserLogbookEntries(limit = 50, offset = 0, _options = {}, userId = 'mock-user') {
+        const userEntries = this.entries.filter((e) => e.createdBy?.id === userId);
+        const docs = userEntries.slice(offset, offset + limit);
+        return {
+            docs,
+            limit,
+            offset,
+            total: userEntries.length,
+            page: Math.floor(offset / limit) + 1,
+            pages: Math.max(1, Math.ceil(userEntries.length / limit)),
+        };
+    }
+    // test helpers
+    seed(entries) {
+        this.entries = [...entries];
+    }
+    clear() {
+        this.entries = [];
+    }
 }
 exports.TaskMockService = TaskMockService;

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

@@ -24,3 +24,13 @@ export interface Organization {
     createdBy?: Author;
     updatedBy?: Author;
 }
+export interface OrganizationName {
+    id: string;
+    name?: string;
+    isDeleted?: boolean;
+}
+export interface UserWithOrgRoles {
+    username: string;
+    orgRoles: string[];
+}
+export type SubscriptionType = 'dev' | 'free' | 'inactive' | 'pro';

package/src/lib/organization.service.d.ts

@@ -1,7 +1,10 @@
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
-import { Organization } from './organization.interface';
+import { Organization, OrganizationName, SubscriptionType, UserWithOrgRoles } from './organization.interface';
 export declare class OrganizationService extends DataService<Organization> {
     constructor(httpClient: HttpClient);
     addOrganizationInvitation(id: string, email: string, roles: string[]): Promise<void>;
+    addOrganizationMembers(id: string, usersWithOrgRoles: UserWithOrgRoles[]): Promise<void>;
+    addSubscriptionToOrganization(id: string, type: SubscriptionType): Promise<Organization>;
+    getOrganizationIdByName(name: string): Promise<OrganizationName>;
 }

package/src/lib/organization.service.js

@@ -9,5 +9,14 @@ class OrganizationService extends data_service_1.DataService {
     addOrganizationInvitation(id, email, roles) {
         return this.httpClient.post(`${this.basePath}/${id}/data/invitations`, { roles, email });
     }
+    addOrganizationMembers(id, usersWithOrgRoles) {
+        return this.httpClient.post(`${this.basePath}/${id}/members`, { usersWithOrgRoles });
+    }
+    addSubscriptionToOrganization(id, type) {
+        return this.httpClient.post(`${this.basePath}/${id}/subscription`, { type });
+    }
+    getOrganizationIdByName(name) {
+        return this.httpClient.get(`${this.basePath}/names/${name}`);
+    }
 }
 exports.OrganizationService = OrganizationService;

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

@@ -1,6 +1,6 @@
 import FormData from 'form-data';
 import { APIBase } from '../api-base';
-import { Paginated, RequestParameter } from '../data.interface';
+import { Filter, Paginated, RequestParameter } from '../data.interface';
 import { DataService } from '../data.service';
 import { HttpClient, TokenOption } from '../http.service';
 import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from '../interfaces';
@@ -11,6 +11,7 @@ declare class BaseService extends APIBase {
 }
 export declare class AssetService extends BaseService {
     constructor(httpClient: HttpClient);
+    count(filter: Filter, options?: TokenOption): Promise<number>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
     addAttachment: (id: string, form: FormData, options?: TokenOption) => Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter, options?: TokenOption): Promise<Paginated<Asset[]>>;
@@ -22,5 +23,6 @@ export declare class AssetService extends BaseService {
     deleteRevision(assetId: string, revisionId: string, options?: TokenOption): Promise<any>;
     findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
     updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Asset[]>>;
 }
 export {};

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

@@ -24,6 +24,10 @@ class AssetService extends BaseService {
             });
         };
     }
+    count(filter, options = {}) {
+        const params = { filter: this.getFilterString(filter) };
+        return this.httpClient.get(`${this.basePath}/count`, { params, ...options });
+    }
     deleteOne(id, force = false, options = {}) {
         return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
     }
@@ -54,5 +58,8 @@ class AssetService extends BaseService {
     updateOneExternal(key, dto, options = {}) {
         return this.httpClient.put(`${this.basePath}/external/${key}`, dto, options);
     }
+    findByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}?name=${encodeURIComponent(name)}`, options);
+    }
 }
 exports.AssetService = AssetService;

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

@@ -2,4 +2,5 @@ export { AiService } from './ai.service';
 export { AssetService } from './asset.service';
 export { AssetTypesService } from './assettypes.service';
 export { EventService } from './event.service';
+export { LabelService } from './label.service';
 export { TimeSeriesService } from './timeseries.service';

package/src/lib/services/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeSeriesService = exports.EventService = exports.AssetTypesService = exports.AssetService = exports.AiService = void 0;
+exports.TimeSeriesService = exports.LabelService = exports.EventService = exports.AssetTypesService = exports.AssetService = exports.AiService = void 0;
 var ai_service_1 = require("./ai.service");
 Object.defineProperty(exports, "AiService", { enumerable: true, get: function () { return ai_service_1.AiService; } });
 var asset_service_1 = require("./asset.service");
@@ -9,5 +9,7 @@ var assettypes_service_1 = require("./assettypes.service");
 Object.defineProperty(exports, "AssetTypesService", { enumerable: true, get: function () { return assettypes_service_1.AssetTypesService; } });
 var event_service_1 = require("./event.service");
 Object.defineProperty(exports, "EventService", { enumerable: true, get: function () { return event_service_1.EventService; } });
+var label_service_1 = require("./label.service");
+Object.defineProperty(exports, "LabelService", { enumerable: true, get: function () { return label_service_1.LabelService; } });
 var timeseries_service_1 = require("./timeseries.service");
 Object.defineProperty(exports, "TimeSeriesService", { enumerable: true, get: function () { return timeseries_service_1.TimeSeriesService; } });

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

@@ -0,0 +1,10 @@
+import { DataService } from '../data.service';
+import { HttpClient, TokenOption } from '../http.service';
+import type { Label, SearchOptions, SearchResult } from '../interfaces';
+export declare class LabelService extends DataService<Label> {
+    constructor(httpClient: HttpClient);
+    addMany(dtos: Label[], options?: TokenOption): Promise<Label[]>;
+    getOneByName(name: string, options?: TokenOption): Promise<Label>;
+    count(options?: TokenOption): Promise<number>;
+    search<K extends keyof Label>(query: SearchOptions<Label, K>, tokenOption?: TokenOption): Promise<SearchResult<Label, K>>;
+}

package/src/lib/{label.service.js → services/label.service.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LabelService = void 0;
-const data_service_1 = require("./data.service");
+const data_service_1 = require("../data.service");
 class LabelService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/labels');
@@ -15,5 +15,8 @@ class LabelService extends data_service_1.DataService {
     count(options = {}) {
         return this.httpClient.get(`${this.basePath}/count`, options);
     }
+    search(query, tokenOption = {}) {
+        return this.httpClient.post(`${this.basePath}/search`, query, tokenOption);
+    }
 }
 exports.LabelService = LabelService;

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

@@ -1,3 +1,4 @@
+import { Author } from './interfaces/resource.interface';
 export interface Task {
     id: string;
     name: string;
@@ -21,3 +22,30 @@ export interface Task {
     updatedAt?: string;
     deletedAt?: string;
 }
+export interface LogbookEntry {
+    id: string;
+    taskId: string;
+    date: string;
+    duration: number;
+    materials: {
+        name: string;
+        quantity: number;
+    }[];
+    comment?: string;
+    source: 'manual' | 'voice' | 'automatic';
+    createdBy: Author;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LogbookEntryDto {
+    date: string;
+    duration: number;
+    materials: {
+        name: string;
+        quantity: number;
+    }[];
+    comment?: string;
+    source?: 'manual' | 'voice' | 'automatic';
+    taskId: string;
+    createdBy?: Author;
+}

package/src/lib/task.service.d.ts

@@ -1,7 +1,8 @@
 import { APIBase } from './api-base';
+import { Paginated } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient, TokenOption } from './http.service';
-import { Task } from './task.interface';
+import { LogbookEntry, LogbookEntryDto, Task } from './task.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<Task>, TrashService<Task> {
 }
@@ -10,5 +11,14 @@ declare class BaseService extends APIBase {
 export declare class TaskService extends BaseService {
     constructor(httpClient: HttpClient);
     createTaskAttachedToAsset(dto: any, options?: TokenOption): Promise<Task>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Task[]>>;
+    findByAsset(assetId: string, options?: TokenOption): Promise<Paginated<Task[]>>;
+    getLogbookEntries(taskId: string, limit?: number, offset?: number, options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
+    addLogbookEntry(taskId: string, entry: LogbookEntryDto, options?: TokenOption): Promise<LogbookEntry>;
+    updateLogbookEntry(taskId: string, entryId: string, entry: Partial<LogbookEntryDto>, options?: TokenOption): Promise<LogbookEntry>;
+    deleteLogbookEntry(taskId: string, entryId: string, options?: TokenOption): Promise<{
+        deleted: boolean;
+    }>;
+    getUserLogbookEntries(limit?: number, offset?: number, options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
 }
 export {};

package/src/lib/task.service.js

@@ -19,5 +19,32 @@ class TaskService extends BaseService {
     createTaskAttachedToAsset(dto, options = {}) {
         return this.httpClient.post(this.basePath, dto, options);
     }
+    findByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}?name=${encodeURIComponent(name)}`, options);
+    }
+    findByAsset(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}?assetRef=${assetId}`, options);
+    }
+    getLogbookEntries(taskId, limit = 50, offset = 0, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${taskId}/logbook`, {
+            ...options,
+            params: { limit: String(limit), offset: String(offset) },
+        });
+    }
+    addLogbookEntry(taskId, entry, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${taskId}/logbook`, entry, options);
+    }
+    updateLogbookEntry(taskId, entryId, entry, options = {}) {
+        return this.httpClient.patch(`${this.basePath}/${taskId}/logbook/${entryId}`, entry, options);
+    }
+    deleteLogbookEntry(taskId, entryId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${taskId}/logbook/${entryId}`, options);
+    }
+    getUserLogbookEntries(limit = 50, offset = 0, options = {}) {
+        return this.httpClient.get(`${this.basePath}/logbook/mine`, {
+            ...options,
+            params: { limit: String(limit), offset: String(offset) },
+        });
+    }
 }
 exports.TaskService = TaskService;

package/src/lib/label.interface.d.ts

@@ -1,8 +0,0 @@
-export interface Label {
-    id: string;
-    name: string;
-    description?: string;
-    color?: string;
-    readPermissions?: string[];
-    readWritePermissions: string[];
-}

package/src/lib/label.service.d.ts

@@ -1,9 +0,0 @@
-import { DataService } from './data.service';
-import { HttpClient, TokenOption } from './http.service';
-import { Label } from './label.interface';
-export declare class LabelService extends DataService<Label> {
-    constructor(httpClient: HttpClient);
-    addMany(dtos: Label[], options?: TokenOption): Promise<Label[]>;
-    getOneByName(name: string, options?: TokenOption): Promise<Label>;
-    count(options?: TokenOption): Promise<number>;
-}