@hahnpro/hpc-api 2025.3.10 → 2025.4.0

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationsMockService = void 0;
+const crypto_1 = require("crypto");
+const _1 = require(".");
+class OrganizationsMockService extends _1.APIBaseMock {
+    constructor(organizations) {
+        super(null);
+        this.data = organizations;
+    }
+    addOrganizationInvitation(id, email, roles) {
+        if (!id || !email || !roles?.length) {
+            return Promise.reject('Bad Request');
+        }
+        return Promise.resolve();
+    }
+    getOrganizationIdByName(name) {
+        const id = this.data.find((org) => org.name === name)?.id;
+        return Promise.resolve({ id });
+    }
+    async addOne(dto) {
+        const dtoWithId = { id: (0, crypto_1.randomUUID)(), ...dto };
+        this.data.push(dtoWithId);
+        return Promise.resolve(dtoWithId);
+    }
+    async getOneCombined(id) {
+        const org = this.data.find((o) => o.id === id);
+        if (!org) {
+            return Promise.reject('Not Found');
+        }
+        else {
+            return Promise.resolve(org);
+        }
+    }
+    addOrganizationRole(id, roleDto) {
+        return Promise.resolve([]);
+    }
+    checkForOrganizationUniqueness(name) {
+        return Promise.resolve(undefined);
+    }
+    deleteOrganizationData(id, elementId, kind) {
+        return Promise.resolve(undefined);
+    }
+    getActiveOrganizationOfUser() {
+        return Promise.resolve(undefined);
+    }
+    getMyOrganizations() {
+        return Promise.resolve([]);
+    }
+    getOrganizationData(id, kinds) {
+        return Promise.resolve(undefined);
+    }
+    getOrganizationMemberById(id, userId) {
+        return Promise.resolve(undefined);
+    }
+    getOrganizationNamesByIds(ids) {
+        return Promise.resolve([]);
+    }
+    getUserOrganizationRoles(ids, userId) {
+        return Promise.resolve(undefined);
+    }
+    getUserOrganizations(userId) {
+        return Promise.resolve([]);
+    }
+    grantOrRevokeRolesOfUser(id, roles, userId) {
+        return Promise.resolve(undefined);
+    }
+    hasActiveSubscription(subscriptionId) {
+        return Promise.resolve(false);
+    }
+    leaveOrganization(id) {
+        return Promise.resolve(undefined);
+    }
+    requestDeletion(id) {
+        return Promise.resolve(undefined);
+    }
+    resendOrganizationInvitation(id, invitationId) {
+        return Promise.resolve(undefined);
+    }
+    setActiveOrganizationOfUser(id) {
+        return Promise.resolve(undefined);
+    }
+    updateOne(id, dto) {
+        return Promise.resolve(undefined);
+    }
+    updateOrganizationRole(id, roleName, dto) {
+        return Promise.resolve([]);
+    }
+}
+exports.OrganizationsMockService = OrganizationsMockService;

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

@@ -1,8 +1,7 @@
-import { APIBase } from '../api-base';
-import { TokenOption } from '../http.service';
-import type { SearchOptions, SearchResult } from '../interfaces';
+import { APIBaseMock } from '.';
+import type { SearchOptions, SearchResult, TokenOption } from '../interfaces';
 import { SearchService } from '../services';
-export declare class SearchMockService extends APIBase implements SearchService {
+export declare class SearchMockService extends APIBaseMock<never> implements SearchService {
     search<T extends {
         id?: string;
     }, K extends keyof T & string = keyof T & string>(query: SearchOptions<T, K>, tokenOption?: TokenOption): Promise<SearchResult<T, K>>;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchMockService = void 0;
-const api_base_1 = require("../api-base");
-class SearchMockService extends api_base_1.APIBase {
+const _1 = require(".");
+class SearchMockService extends _1.APIBaseMock {
     search(query, tokenOption = {}) {
         throw new Error('Method not implemented.');
     }

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

@@ -1,9 +1,6 @@
-import { Paginated, RequestParameter } from '../data.interface';
-import { Secret } from '../secret.interface';
-import { SecretService } from '../secret.service';
-import { APIBaseMock } from './api-base.mock';
-import { DataMockService } from './data.mock.service';
-import { TrashMockService } from './trash.mock.service';
+import { APIBaseMock, DataMockService, TrashMockService } from '.';
+import { Paginated, RequestParameter, Secret } from '../interfaces';
+import { SecretService } from '../services';
 interface BaseService extends DataMockService<Secret>, TrashMockService<Secret> {
 }
 declare class BaseService extends APIBaseMock<Secret> {
@@ -11,6 +8,6 @@ declare class BaseService extends APIBaseMock<Secret> {
 export declare class SecretMockService extends BaseService implements SecretService {
     constructor(secrets: Secret[]);
     deleteOne(contentId: string, force?: boolean): Promise<Secret>;
-    getMany(params?: RequestParameter): Promise<Paginated<Secret[]>>;
+    getMany(params?: RequestParameter): Promise<Paginated<Secret>>;
 }
 export {};

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

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretMockService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+const _1 = require(".");
+let BaseService = class BaseService extends _1.APIBaseMock {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+    (0, ts_mixer_1.mix)(_1.DataMockService, _1.TrashMockService)
 ], BaseService);
 class SecretMockService extends BaseService {
     constructor(secrets) {

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

@@ -1,10 +1,6 @@
-import { Paginated, RequestParameter } from '../data.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';
-import { TrashMockService } from './trash.mock.service';
+import { APIBaseMock, DataMockService, TrashMockService } from '.';
+import { LogbookEntry, LogbookEntryDto, Paginated, RequestParameter, Task, TokenOption } from '../interfaces';
+import { TaskService } from '../services';
 interface BaseService extends DataMockService<Task>, TrashMockService<Task> {
 }
 declare class BaseService extends APIBaseMock<Task> {
@@ -14,16 +10,16 @@ export declare class TaskMockService extends BaseService implements TaskService
     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[]>>;
+    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[]>>;
+    getUserLogbookEntries(limit?: number, offset?: number, _options?: TokenOption, userId?: string): Promise<Paginated<LogbookEntry>>;
     seed(entries: LogbookEntry[]): void;
     clear(): void;
 }

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

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskMockService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+const _1 = require(".");
+let BaseService = class BaseService extends _1.APIBaseMock {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+    (0, ts_mixer_1.mix)(_1.DataMockService, _1.TrashMockService)
 ], BaseService);
 class TaskMockService extends BaseService {
     constructor(tasks, logbookEntries = []) {
@@ -73,7 +71,7 @@ class TaskMockService extends BaseService {
         const entry = {
             id,
             taskId,
-            date: dto.date || now,
+            date: dto.date || new Date(),
             duration: dto.duration ?? 0,
             materials: dto.materials || [],
             comment: dto.comment || '',

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

@@ -1,9 +1,6 @@
-import { Paginated, RequestParameter } from '../data.interface';
-import { TimeSeries, TimeSeriesValue, TS_GROUPS } from '../interfaces';
+import { APIBaseMock, DataMockService, TrashMockService } from '.';
+import { Paginated, RequestParameter, TimeSeries, TimeSeriesValue, TS_GROUPS } from '../interfaces';
 import { TimeSeriesService } from '../services';
-import { APIBaseMock } from './api-base.mock';
-import { DataMockService } from './data.mock.service';
-import { TrashMockService } from './trash.mock.service';
 interface BaseService extends DataMockService<TimeSeries & {
     data: TimeSeriesValue[];
 }>, TrashMockService<TimeSeries & {
@@ -17,9 +14,9 @@ declare class BaseService extends APIBaseMock<TimeSeries & {
 export declare class TimeseriesMockService extends BaseService implements TimeSeriesService {
     constructor(timeseries: TimeSeries[], timeseriesValues: TimeSeriesValue[][]);
     deleteOne(tsmId: string, force?: boolean): Promise<TimeSeries>;
-    getMany(params?: RequestParameter): Promise<Paginated<(TimeSeries & {
+    getMany(params?: RequestParameter): Promise<Paginated<TimeSeries & {
         data: TimeSeriesValue[];
-    })[]>>;
+    }>>;
     addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
         [timestamp: string]: any;
     }, metadata?: Record<string, any>): Promise<TimeSeries>;
@@ -34,7 +31,7 @@ export declare class TimeseriesMockService extends BaseService implements TimeSe
     addValue(id: string, value: {
         [timestamp: string]: any;
     }): Promise<void>;
-    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries[]>>;
+    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries>>;
     getMostRecentValue(id: string, before: Date): Promise<TimeSeriesValue>;
     getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
     getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;

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

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimeseriesMockService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+const _1 = require(".");
+let BaseService = class BaseService extends _1.APIBaseMock {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+    (0, ts_mixer_1.mix)(_1.DataMockService, _1.TrashMockService)
 ], BaseService);
 class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {

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

@@ -1,11 +1,9 @@
-import { Paginated, RequestParameter } from '../data.interface';
-import { TrashService } from '../trash.service';
-import { APIBaseMock } from './api-base.mock';
+import { APIBaseMock } from '.';
+import { Paginated, RequestParameter } from '../interfaces';
+import { TrashService } from '../services';
 export declare class TrashMockService<T extends {
     id?: string;
-}> extends TrashService<T> implements APIBaseMock<T> {
-    data: T[];
-    protected deleteOnecbf: any;
+}> extends APIBaseMock<T> implements TrashService<T> {
     constructor();
     trashRestoreAll(): Promise<T[]>;
     trashRestoreOne(id: string): Promise<T>;
@@ -13,6 +11,6 @@ export declare class TrashMockService<T extends {
         acknowledged: boolean;
         deletedCount: number;
     }>;
-    getTrash(params?: RequestParameter): Promise<Paginated<T[]>>;
-    protected getItems(params: RequestParameter, deleted?: boolean): Paginated<T[]>;
+    getTrash(params?: RequestParameter): Promise<Paginated<T>>;
+    protected getItems(params: RequestParameter, deleted?: boolean): Paginated<T>;
 }

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

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashMockService = void 0;
-const trash_service_1 = require("../trash.service");
-class TrashMockService extends trash_service_1.TrashService {
+const _1 = require(".");
+class TrashMockService extends _1.APIBaseMock {
     constructor() {
-        super(null, null);
-        this.data = [];
+        super(null);
     }
     trashRestoreAll() {
         const deleted = this.data.filter((v) => v['deletedAt']);

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

@@ -1,4 +1,4 @@
-import { UserService } from '../user.service';
+import { UserService } from '../services';
 import { UserInit } from './api.mock';
 export declare class UserMockService extends UserService {
     private users;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMockService = void 0;
-const user_service_1 = require("../user.service");
-class UserMockService extends user_service_1.UserService {
+const services_1 = require("../services");
+class UserMockService extends services_1.UserService {
     constructor(users) {
         super(null);
         this.users = users;

package/src/lib/mock/utils/index.d.ts

@@ -0,0 +1 @@
+export { sortData } from './sort-data.function';

package/src/lib/mock/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortData = void 0;
+var sort_data_function_1 = require("./sort-data.function");
+Object.defineProperty(exports, "sortData", { enumerable: true, get: function () { return sort_data_function_1.sortData; } });

package/src/lib/mock/utils/sort-data.function.d.ts

@@ -0,0 +1 @@
+export declare function sortData<T>(data: T[], sort: string): void;

package/src/lib/mock/utils/sort-data.function.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortData = sortData;
+function sortData(data, sort) {
+    const descending = sort.startsWith('-');
+    const sortString = descending ? sort.substring(1) : sort;
+    const compareFn = (a, b) => {
+        let aValue = a[sortString];
+        let bValue = b[sortString];
+        if (['updatedAt', 'createdAt', 'deletedAt'].includes(sortString)) {
+            aValue = new Date(a[sortString]).valueOf();
+            bValue = new Date(b[sortString]).valueOf();
+        }
+        return descending ? bValue - aValue : aValue - bValue;
+    };
+    data.sort(compareFn);
+}

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

@@ -1,6 +1,6 @@
-import { VaultSecret } from '../vault.interface';
-import { VaultService } from '../vault.service';
-import { DataMockService } from './data.mock.service';
+import { DataMockService } from '.';
+import { VaultSecret } from '../interfaces';
+import { VaultService } from '../services';
 export declare class VaultMockService extends DataMockService<VaultSecret> implements VaultService {
     constructor(secrets: VaultSecret[]);
     getSecret(name: string, version?: number): Promise<string>;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultMockService = void 0;
-const data_mock_service_1 = require("./data.mock.service");
-class VaultMockService extends data_mock_service_1.DataMockService {
+const _1 = require(".");
+class VaultMockService extends _1.DataMockService {
     constructor(secrets) {
         super();
         this.data = secrets;

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

@@ -1,9 +1,8 @@
+import { HttpClientService } from '.';
 import { APIBase } from '../api-base';
-import { Paginated } from '../data.interface';
-import { HttpClient, TokenOption } from '../http.service';
-import { AiAssistant, Message, SpeechToken, Thread, ThreadPopulated } from '../interfaces';
+import { AiAssistant, Message, Paginated, SpeechToken, Thread, ThreadPopulated, TokenOption } from '../interfaces';
 export declare class AiService extends APIBase {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     addMessage(message: string, threadId?: string, assistantId?: string, context?: Record<string, unknown>): Promise<Message>;
     createThread(assistantId: string, isEphemeral?: boolean): Promise<ThreadPopulated>;
     getLatestAssistantThread(assistantId: string): Promise<ThreadPopulated>;
@@ -11,7 +10,7 @@ export declare class AiService extends APIBase {
     getAssistant(assistantId: string): Promise<AiAssistant>;
     getAssistants(): Promise<AiAssistant[]>;
     getSpeechToken(): Promise<SpeechToken>;
-    getThreadMessages(threadId: string): Promise<Paginated<Message[]>>;
+    getThreadMessages(threadId: string): Promise<Paginated<Message>>;
     getThread(threadId: string): Promise<ThreadPopulated>;
     getLatestThread(): Promise<ThreadPopulated>;
     listThreads(assistantIds?: string[], params?: {}, options?: TokenOption): Promise<ThreadPopulated[]>;

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

@@ -0,0 +1,5 @@
+import { DataService, HttpClientService } from '.';
+import { Alert } from '../interfaces';
+export declare class AlertService extends DataService<Alert> {
+    constructor(httpClient: HttpClientService);
+}

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlertService = void 0;
-const data_service_1 = require("./data.service");
-class AlertService extends data_service_1.DataService {
+const _1 = require(".");
+class AlertService extends _1.DataService {
     constructor(httpClient) {
         super(httpClient, '/alerts');
     }

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

@@ -1,27 +1,23 @@
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
-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';
-import { AddToProperty, RemoveFromProperty } from '../interfaces/asset.interface';
-import { TrashService } from '../trash.service';
+import { AddToProperty, Asset, AssetRevision, Attachment, EventCause, EventLevelOverride, Filter, Paginated, RemoveFromProperty, RequestParameter, TokenOption } from '../interfaces';
 import { CrossPlatformFormData } from '../utils';
 interface BaseService extends DataService<Asset>, TrashService<Asset> {
 }
 declare class BaseService extends APIBase {
 }
 export declare class AssetService extends BaseService {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     count(filter: Filter, options?: TokenOption): Promise<number>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
     addAttachment: (id: string, form: CrossPlatformFormData, options?: TokenOption) => Promise<Asset>;
     addElementToProperty(id: string, dto: AddToProperty): Promise<Asset>;
     removeElementFromProperty(id: string, dto: RemoveFromProperty): Promise<Asset>;
-    getChildren(assetId: string, params?: RequestParameter, options?: TokenOption): Promise<Paginated<Asset[]>>;
-    getAttachments(assetId: string, options?: TokenOption): Promise<Paginated<Attachment[]>>;
+    getChildren(assetId: string, params?: RequestParameter, options?: TokenOption): Promise<Paginated<Asset>>;
+    getAttachments(assetId: string, options?: TokenOption): Promise<Paginated<Attachment>>;
     getEventLevelOverride(ids: string[], causes: string[], options?: TokenOption): Promise<EventLevelOverride>;
     updateEventCausesAsset(id: string, dto: EventCause, options?: TokenOption): Promise<Asset>;
-    getRevisions(assetId: string, options?: TokenOption): Promise<Paginated<AssetRevision[]>>;
+    getRevisions(assetId: string, options?: TokenOption): Promise<Paginated<AssetRevision>>;
     rollback(assetId: string, revisionId: string, options?: TokenOption): Promise<Asset>;
     deleteRevision(assetId: string, revisionId: string, options?: TokenOption): Promise<any>;
     findOneExternal(key: string, options?: TokenOption): Promise<Asset>;

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

@@ -3,14 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
 const api_base_1 = require("../api-base");
-const data_service_1 = require("../data.service");
-const trash_service_1 = require("../trash.service");
 const utils_1 = require("../utils");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, _1.TrashService)
 ], BaseService);
 class AssetService extends BaseService {
     constructor(httpClient) {
@@ -25,7 +24,7 @@ class AssetService extends BaseService {
         };
     }
     count(filter, options = {}) {
-        const params = { filter: this.getFilterString(filter) };
+        const params = { filter: (0, utils_1.getFilterString)(filter) };
         return this.httpClient.get(`${this.basePath}/count`, { params, ...options });
     }
     deleteOne(id, force = false, options = {}) {

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

@@ -1,16 +1,13 @@
+import { DataService, HttpClientService, TrashService } from '.';
 import { APIBase } from '../api-base';
-import { Paginated } from '../data.interface';
-import { DataService } from '../data.service';
-import { HttpClient, TokenOption } from '../http.service';
-import { AssetType, Template } from '../interfaces';
-import { TrashService } from '../trash.service';
+import { AssetType, Paginated, Template, TokenOption } from '../interfaces';
 interface BaseService extends DataService<AssetType>, TrashService<AssetType> {
 }
 declare class BaseService extends APIBase {
 }
 export declare class AssetTypesService extends BaseService {
-    constructor(httpClient: HttpClient);
-    getRevisions(id: string, options?: TokenOption): Promise<Paginated<AssetType[]>>;
+    constructor(httpClient: HttpClientService);
+    getRevisions(id: string, options?: TokenOption): Promise<Paginated<AssetType>>;
     rollback(id: string, revisionId: string, options?: TokenOption): Promise<AssetType>;
     deleteRevision(id: string, revisionId: string, options?: TokenOption): Promise<any>;
     getTemplate(id: string, templateName: string, options?: TokenOption): Promise<Template>;

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

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetTypesService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
+const _1 = require(".");
 const api_base_1 = require("../api-base");
-const data_service_1 = require("../data.service");
-const trash_service_1 = require("../trash.service");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, _1.TrashService)
 ], BaseService);
 class AssetTypesService extends BaseService {
     constructor(httpClient) {

package/src/lib/{content.service.d.ts → services/content.service.d.ts}

@@ -1,15 +1,13 @@
-import { APIBase } from './api-base';
-import { Content, ReturnType } from './content.interface';
-import { DataService } from './data.service';
-import { Config, HttpClient, TokenOption } from './http.service';
-import { TrashService } from './trash.service';
-import { CrossPlatformFormData } from './utils';
+import { DataService, HttpClientService, TrashService } from '.';
+import { APIBase } from '../api-base';
+import { Config, Content, ReturnType, TokenOption } from '../interfaces';
+import { CrossPlatformFormData } from '../utils';
 interface BaseService extends DataService<Content>, TrashService<Content> {
 }
 declare class BaseService extends APIBase {
 }
 export declare class ContentService extends BaseService {
-    constructor(httpClient: HttpClient);
+    constructor(httpClient: HttpClientService);
     upload: (form: CrossPlatformFormData, options?: Config) => Promise<Content>;
     download(id: string, raw?: boolean, options?: TokenOption): Promise<Blob | ArrayBuffer>;
     download(id: string, returnType: ReturnType.TEXT, options?: TokenOption): Promise<string>;

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

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentService = void 0;
 const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
-const api_base_1 = require("./api-base");
-const content_interface_1 = require("./content.interface");
-const data_service_1 = require("./data.service");
-const trash_service_1 = require("./trash.service");
-const utils_1 = require("./utils");
+const _1 = require(".");
+const api_base_1 = require("../api-base");
+const interfaces_1 = require("../interfaces");
+const utils_1 = require("../utils");
 let BaseService = class BaseService extends api_base_1.APIBase {
 };
 BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+    (0, ts_mixer_1.mix)(_1.DataService, _1.TrashService)
 ], BaseService);
 class ContentService extends BaseService {
     constructor(httpClient) {
@@ -29,22 +28,22 @@ class ContentService extends BaseService {
     async download(id, second, options = {}) {
         let returnType;
         if (typeof second === 'boolean' || second == null) {
-            returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
+            returnType = second ? interfaces_1.ReturnType.ARRAYBUFFER : interfaces_1.ReturnType.BLOB;
         }
         else {
             returnType = second;
         }
         const url = `${this.basePath}/${id}/download`;
         switch (returnType) {
-            case content_interface_1.ReturnType.TEXT:
+            case interfaces_1.ReturnType.TEXT:
                 return this.httpClient.get(url, { responseType: 'text', ...options });
-            case content_interface_1.ReturnType.JSON:
+            case interfaces_1.ReturnType.JSON:
                 return this.httpClient.get(url, { responseType: 'json', ...options });
-            case content_interface_1.ReturnType.NODEBUFFER:
+            case interfaces_1.ReturnType.NODEBUFFER:
                 return Buffer.from(new Uint8Array(await this.httpClient.get(url, { responseType: 'arraybuffer', ...options })));
-            case content_interface_1.ReturnType.BLOB:
+            case interfaces_1.ReturnType.BLOB:
                 return this.httpClient.get(url, { responseType: 'blob', ...options });
-            case content_interface_1.ReturnType.ARRAYBUFFER:
+            case interfaces_1.ReturnType.ARRAYBUFFER:
                 return this.httpClient.get(url, { responseType: 'arraybuffer', ...options });
         }
     }

package/src/lib/{data.service.d.ts → services/data.service.d.ts}

@@ -1,6 +1,5 @@
-import { APIBase } from './api-base';
-import { DataInterface, Filter, Paginated, RequestParameter } from './data.interface';
-import { Config, TokenOption } from './http.service';
+import { APIBase } from '../api-base';
+import { Config, DataInterface, Filter, Paginated, RequestParameter, TokenOption } from '../interfaces';
 export declare class DataService<T> extends APIBase implements DataInterface<T> {
     addOne(dto: any, options?: TokenOption & {
         [key: string]: any;
@@ -9,7 +8,7 @@ export declare class DataService<T> extends APIBase implements DataInterface<T>
     getOne(id: string, options?: TokenOption & {
         [key: string]: any;
     }): Promise<T>;
-    getMany(params?: RequestParameter, options?: Config): Promise<Paginated<T[]>>;
+    getMany(params?: RequestParameter, options?: Config): Promise<Paginated<T>>;
     /**
      * Filters the elements by the passed properties. The object with these properties has to be of the form:
      * {
@@ -20,10 +19,9 @@ export declare class DataService<T> extends APIBase implements DataInterface<T>
      * @param params Other request parameters.
      * @param options Parameters for authentication
      */
-    getManyFiltered(filter: Filter, params?: RequestParameter, options?: TokenOption): Promise<Paginated<T[]>>;
+    getManyFiltered(filter: Filter, params?: RequestParameter, options?: TokenOption): Promise<Paginated<T>>;
     updateOne(id: string, dto: any, options?: TokenOption & {
         [key: string]: any;
     }): Promise<T>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
-    protected getFilterString(filter: Filter): string;
 }