@attlaz/client 1.77.1

package/dist/Service/StorageEndpoint.js

@@ -0,0 +1,130 @@
+import { StorageInformation } from '../Model/Storage/StorageInformation.js';
+import { StorageItem } from '../Model/Storage/StorageItem.js';
+import { StorageItemInformation } from '../Model/Storage/StorageItemInformation.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class StorageEndpoint extends Endpoint {
+    async getInformation(projectEnvironmentId, storageType) {
+        const cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType;
+        try {
+            const parser = (raw) => {
+                const storageInformation = new StorageInformation();
+                storageInformation.bytes = raw.bytes;
+                storageInformation.bytes_limit = raw.bytes_limit;
+                storageInformation.items = raw.items;
+                // Prefer the new `buckets` field; fall back to the legacy `pools` for older API responses.
+                storageInformation.buckets = (raw.buckets ?? raw.pools);
+                return storageInformation;
+            };
+            const result = await this.requestObject(cmd, null, parser, 'GET');
+            return result.getData();
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage information', ex);
+            }
+            throw ex;
+        }
+    }
+    async clearBucket(projectEnvironmentId, storageType, bucketKey) {
+        const cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + bucketKey;
+        try {
+            const parser = (raw) => raw.deleted;
+            const result = await this.requestObject(cmd, null, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to clear storage pool: wrong response from API');
+            }
+            return re.deleted;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage information', ex);
+            }
+            throw ex;
+        }
+    }
+    async getBucketItemsInformation(projectEnvironmentId, storageType, bucketKey, pagination = null) {
+        const qs = new QueryString('/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + bucketKey + '/items');
+        qs.addPagination(pagination);
+        try {
+            const result = await this.requestCollection(qs, StorageItemInformation.parse, null, 'GET');
+            return result;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage information', ex);
+            }
+            throw ex;
+        }
+    }
+    /** @deprecated Renamed to getBucketItemsInformation. Kept for backwards compatibility. */
+    async getPoolItemsInformation(projectEnvironmentId, storageType, bucketKey, pagination = null) {
+        return this.getBucketItemsInformation(projectEnvironmentId, storageType, bucketKey, pagination);
+    }
+    /** @deprecated Renamed to clearBucket. Kept for backwards compatibility. */
+    async clearPool(projectEnvironmentId, storageType, bucketKey) {
+        return this.clearBucket(projectEnvironmentId, storageType, bucketKey);
+    }
+    async getItem(projectEnvironmentId, storageType, bucketKey, storageItemKey) {
+        const cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + bucketKey + '/items/' + storageItemKey;
+        try {
+            const result = await this.requestObject(cmd, null, StorageItem.parse, 'GET');
+            return result.getData();
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage item', ex);
+            }
+            throw ex;
+        }
+    }
+    async getBucketItem(storageBucketId, storageItemKey) {
+        const cmd = '/storage-buckets/' + storageBucketId + '/items/' + storageItemKey;
+        try {
+            const result = await this.requestObject(cmd, null, StorageItem.parse, 'GET');
+            return result.getData();
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage item', ex);
+            }
+            throw ex;
+        }
+    }
+    async setItem(projectEnvironmentId, storageType, bucketKey, storageItem) {
+        const cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + bucketKey + '/items/' + storageItem.key;
+        try {
+            const result = await this.requestObject(cmd, storageItem, StorageItem.parse, 'POST');
+            const savedItem = result.getData();
+            if (savedItem === null) {
+                throw new Error('Unable to save storage item: wrong response from API');
+            }
+            return savedItem;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage information', ex);
+            }
+            throw ex;
+        }
+    }
+    async deleteItem(projectEnvironmentId, storageType, bucketKey, storageItemKey) {
+        const cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + bucketKey + '/items/' + storageItemKey;
+        try {
+            const parser = (raw) => ({ deleted: raw.deleted });
+            const result = await this.requestObject(cmd, null, parser, 'DELETE');
+            const x = result.getData();
+            if (x === null) {
+                throw new Error('Unable to delete storage item: wrong response from API');
+            }
+            return x.deleted;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get storage information', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/SubscriberEndpoint.d.ts

@@ -0,0 +1,9 @@
+import { Subscriber } from '../Model/Messaging/Subscriber.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class SubscriberEndpoint extends Endpoint {
+    getSubscribersByFlow(flowId: string, projectEnvironmentId?: string | null, pagination?: CursorPagination | null): Promise<CollectionResult<Subscriber>>;
+    getSubscribersByChannel(channelId: string, pagination?: CursorPagination | null): Promise<CollectionResult<Subscriber>>;
+    save(subscriber: Subscriber): Promise<Subscriber>;
+}

package/dist/Service/SubscriberEndpoint.js

@@ -0,0 +1,29 @@
+import { Subscriber } from '../Model/Messaging/Subscriber.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class SubscriberEndpoint extends Endpoint {
+    async getSubscribersByFlow(flowId, projectEnvironmentId = null, pagination = null) {
+        const qu = new QueryString('/flows/' + flowId + '/subscribers');
+        if (projectEnvironmentId !== null && projectEnvironmentId !== undefined) {
+            qu.set('environment', projectEnvironmentId);
+        }
+        qu.addPagination(pagination);
+        const result = await this.requestCollection(qu, Subscriber.parseRaw);
+        return result;
+    }
+    async getSubscribersByChannel(channelId, pagination = null) {
+        const qu = new QueryString('/channels/' + channelId + '/subscribers');
+        qu.addPagination(pagination);
+        const result = await this.requestCollection(qu, Subscriber.parseRaw);
+        return result;
+    }
+    async save(subscriber) {
+        const url = '/flows/' + subscriber.flowId + '/subscribers';
+        const result = await this.requestObject(url, subscriber, Subscriber.parseRaw, 'POST');
+        const createdSubscriber = result.getData();
+        if (createdSubscriber === null) {
+            throw new Error('Subscriber not created');
+        }
+        return createdSubscriber;
+    }
+}

package/dist/Service/TriggerEndpoint.d.ts

@@ -0,0 +1,10 @@
+import { Trigger } from '../Model/Trigger/Trigger.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class TriggerEndpoint extends Endpoint {
+    getByFlow(flowId: string, projectEnvironmentId?: string | null, pagination?: CursorPagination | null): Promise<CollectionResult<Trigger>>;
+    getByCodeSource(codeSourceId: string, pagination?: CursorPagination | null): Promise<CollectionResult<Trigger>>;
+    getById(id: string): Promise<Trigger | null>;
+    save(trigger: Trigger): Promise<Trigger>;
+}

package/dist/Service/TriggerEndpoint.js

@@ -0,0 +1,67 @@
+import { Trigger } from '../Model/Trigger/Trigger.js';
+import { Utils } from '../Utils.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class TriggerEndpoint extends Endpoint {
+    async getByFlow(flowId, projectEnvironmentId = null, pagination = null) {
+        try {
+            const queryString = new QueryString('/triggers/rfr/' + flowId + '');
+            queryString.addPagination(pagination);
+            let parameters = null;
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+                parameters = { environment: projectEnvironmentId };
+            }
+            const rawTriggers = await this.requestCollection(queryString, Trigger.parse, parameters);
+            return rawTriggers;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load triggers: ', error);
+            }
+            throw error;
+        }
+    }
+    async getByCodeSource(codeSourceId, pagination = null) {
+        try {
+            const queryString = new QueryString('/triggers/csd/' + codeSourceId + '');
+            queryString.addPagination(pagination);
+            const rawTriggers = await this.requestCollection(queryString, Trigger.parse, null);
+            return rawTriggers;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load triggers: ', error);
+            }
+            throw error;
+        }
+    }
+    async getById(id) {
+        try {
+            const result = await this.requestObject('/triggers/' + id, null, Trigger.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load trigger by id: ', error);
+            }
+            throw error;
+        }
+    }
+    async save(trigger) {
+        try {
+            const url = '/flows/' + trigger.flowId + '/triggers';
+            const result = await this.requestObject(url, trigger, Trigger.parse, 'POST');
+            const createdTrigger = result.getData();
+            if (createdTrigger === null) {
+                throw new Error('Unable save trigger: wrong response from API');
+            }
+            return createdTrigger;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save trigger: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/UserActionEndpoint.d.ts

@@ -0,0 +1,16 @@
+import { UserAction } from '../Model/User/UserAction.js';
+import { UserActionFilter } from '../Model/User/UserActionFilter.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class UserActionEndpoint extends Endpoint {
+    getWorkspaceMemberActions(workspaceId: string, memberId: string, pagination?: CursorPagination | null): Promise<CollectionResult<UserAction>>;
+    getUserActions(userId: string, pagination?: CursorPagination | null): Promise<CollectionResult<UserAction>>;
+    getByResource(resourceId: string, resourceType: string, pagination?: CursorPagination | null): Promise<CollectionResult<UserAction>>;
+    getAll(pagination?: CursorPagination | null, filter?: UserActionFilter | null): Promise<CollectionResult<UserAction>>;
+    /** Distinct users that appear in the audit log, resolved to display-safe summaries (for the user filter). */
+    getDistinctUsers(): Promise<UserSummary[]>;
+    private static parseSummary;
+    private static parse;
+}

package/dist/Service/UserActionEndpoint.js

@@ -0,0 +1,96 @@
+import { Utils } from '../Utils.js';
+import { UserAction } from '../Model/User/UserAction.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { State } from '../Model/State.js';
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class UserActionEndpoint extends Endpoint {
+    async getWorkspaceMemberActions(workspaceId, memberId, pagination = null) {
+        try {
+            const queryString = new QueryString('/workspaces/' + workspaceId + '/members/' + memberId + '/actions');
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, UserActionEndpoint.parse, null, 'GET');
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter configuration: ', error);
+            }
+            throw error;
+        }
+    }
+    async getUserActions(userId, pagination = null) {
+        try {
+            const queryString = new QueryString('/users/' + userId + '/actions');
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, UserActionEndpoint.parse, null, 'GET');
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter configuration: ', error);
+            }
+            throw error;
+        }
+    }
+    async getByResource(resourceId, resourceType, pagination = null) {
+        try {
+            const queryString = new QueryString('/resources/' + resourceType + '/' + resourceId + '/actions');
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, UserActionEndpoint.parse, null, 'GET');
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter configuration: ', error);
+            }
+            throw error;
+        }
+    }
+    async getAll(pagination = null, filter = null) {
+        const queryString = new QueryString('/audit-logs');
+        queryString.addPagination(pagination);
+        if (filter !== null) {
+            if (filter.userIds !== undefined && filter.userIds.length > 0) {
+                queryString.set('user', filter.userIds);
+            }
+            if (filter.entityId !== undefined) {
+                queryString.set('entity', filter.entityId);
+            }
+            if (filter.timeFrom !== undefined) {
+                queryString.set('time_from', filter.timeFrom.toISOString());
+            }
+            if (filter.timeTo !== undefined) {
+                queryString.set('time_to', filter.timeTo.toISOString());
+            }
+        }
+        return await this.requestCollection(queryString, UserActionEndpoint.parse, null, 'GET');
+    }
+    /** Distinct users that appear in the audit log, resolved to display-safe summaries (for the user filter). */
+    async getDistinctUsers() {
+        const queryString = new QueryString('/audit-logs/users');
+        const result = await this.requestCollection(queryString, UserActionEndpoint.parseSummary, null, 'GET');
+        return result.getData();
+    }
+    static parseSummary(raw) {
+        const summary = new UserSummary();
+        summary.id = raw.id;
+        summary.type = raw.type;
+        summary.state = (raw.state === null || raw.state === undefined) ? null : State.fromString(raw.state);
+        summary.displayName = raw.display_name;
+        return summary;
+    }
+    static parse(rawUserEvent) {
+        const userAction = new UserAction();
+        userAction.id = rawUserEvent.id;
+        userAction.userId = rawUserEvent.user;
+        userAction.workspaceId = rawUserEvent.workspace;
+        userAction.action = rawUserEvent.action;
+        userAction.entityId = rawUserEvent.entity;
+        userAction.entityType = rawUserEvent.entity_type;
+        userAction.description = rawUserEvent.description;
+        userAction.ip = rawUserEvent.ip;
+        userAction.time = Utils.parseRawDate(rawUserEvent.time);
+        userAction.result = rawUserEvent.result;
+        userAction.data = DataValueCollection.fromObject(rawUserEvent.data);
+        return userAction;
+    }
+}

package/dist/Service/UserEndpoint.d.ts

@@ -0,0 +1,29 @@
+import { UserAuthProvider } from '../Model/User/UserAuthProvider.js';
+import { User } from '../Model/User/User.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+import { UserNotificationSession } from '../Model/User/UserNotificationSession.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+export declare class UserEndpoint extends Endpoint {
+    getUser(): Promise<User | null>;
+    removeAuthProvider(providerId: string): Promise<boolean>;
+    /**
+     * Resolve display-safe summaries for a set of user ids (e.g. to show "Requested by" names in a
+     * list). The server applies visibility rules and returns tombstones ("Unknown user" / "Removed
+     * user") rather than leaking anything the caller isn't allowed to see.
+     */
+    getSummaries(userIds: string[]): Promise<UserSummary[]>;
+    private static parseSummary;
+    getAuthProviders(): Promise<CollectionResult<UserAuthProvider>>;
+    getPermissions(): Promise<CollectionResult<{
+        key: string;
+        allowed: boolean;
+    }>>;
+    update(user: User): Promise<User>;
+    create(user: User, password: string, invitationCode?: string | null): Promise<User>;
+    requestResetPassword(email: string): Promise<boolean>;
+    resetPassword(code: string, password: string): Promise<boolean>;
+    createWebPush(session: UserNotificationSession): Promise<boolean>;
+    getSessions(pagination: CursorPagination): Promise<CollectionResult<UserNotificationSession>>;
+}

package/dist/Service/UserEndpoint.js

@@ -0,0 +1,178 @@
+import { UserAuthProvider } from '../Model/User/UserAuthProvider.js';
+import { User } from '../Model/User/User.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { Endpoint } from './Endpoint.js';
+import { UserNotificationSession } from '../Model/User/UserNotificationSession.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { State } from '../Model/State.js';
+export class UserEndpoint extends Endpoint {
+    async getUser() {
+        const cmd = '/users';
+        const rawUser = await this.requestObject(cmd, null, User.parse);
+        return rawUser.getData();
+    }
+    async removeAuthProvider(providerId) {
+        try {
+            const parser = (raw) => ({ deleted: raw.deleted });
+            const result = await this.requestObject('/users/auth/providers', { provider: providerId }, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to remove auth provider: wrong response from API');
+            }
+            return re.deleted;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to assign auth provider: ', e);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Resolve display-safe summaries for a set of user ids (e.g. to show "Requested by" names in a
+     * list). The server applies visibility rules and returns tombstones ("Unknown user" / "Removed
+     * user") rather than leaking anything the caller isn't allowed to see.
+     */
+    async getSummaries(userIds) {
+        if (userIds.length === 0) {
+            return [];
+        }
+        const queryString = new QueryString('/users/summaries');
+        queryString.set('id', userIds);
+        const result = await this.requestCollection(queryString, UserEndpoint.parseSummary, null, 'GET');
+        return result.getData();
+    }
+    static parseSummary(raw) {
+        const summary = new UserSummary();
+        summary.id = raw.id;
+        summary.type = raw.type;
+        summary.state = (raw.state === null || raw.state === undefined) ? null : State.fromString(raw.state);
+        summary.displayName = raw.display_name;
+        return summary;
+    }
+    async getAuthProviders() {
+        const cmd = '/users/auth/providers';
+        const rawAuthProviders = await this.requestCollection(cmd, UserAuthProvider.parse);
+        return rawAuthProviders;
+    }
+    async getPermissions() {
+        const cmd = '/permissions';
+        const parser = (raw) => ({ key: raw.key, allowed: raw.allowed });
+        const data = await this.requestCollection(cmd, parser);
+        return data;
+    }
+    async update(user) {
+        try {
+            const url = '/users/' + user.id;
+            const result = await this.requestObject(url, user, User.parse, 'POST');
+            const updatedUser = result.getData();
+            if (updatedUser === null) {
+                throw new Error('User not updated');
+            }
+            return updatedUser;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save user: ', e);
+            }
+            throw e;
+        }
+    }
+    async create(user, password, invitationCode = null) {
+        try {
+            const url = '/users/';
+            const data = { ...user, password, invitation_code: invitationCode };
+            const result = await this.requestObject(url, data, User.parse, 'PUT', false);
+            const createdUser = result.getData();
+            if (createdUser === null) {
+                throw new Error('User not created');
+            }
+            return createdUser;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create user: ', e);
+            }
+            throw e;
+        }
+    }
+    async requestResetPassword(email) {
+        try {
+            const url = '/users/resetpassword';
+            const parser = (raw) => ({ requested: raw.requested });
+            const result = await this.requestObject(url, { email }, parser, 'POST', false);
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to request password reset: wrong response from API');
+            }
+            return re.requested;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save user: ', e);
+            }
+            throw e;
+        }
+    }
+    async resetPassword(code, password) {
+        try {
+            const url = '/users/resetpassword/' + code;
+            const parser = (raw) => ({ updated: raw.updated });
+            const result = await this.requestObject(url, { password }, parser, 'POST', false);
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to reset password: wrong response from API');
+            }
+            return re.updated;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save user: ', e);
+            }
+            throw e;
+        }
+    }
+    async createWebPush(session) {
+        try {
+            const url = '/webpush';
+            const data = {
+                session: session.session,
+                subscription: session.subscription,
+                expires_at: session.expiresAt,
+                os: session.os,
+                browser: session.browser,
+            };
+            const parser = (raw) => ({ created: raw.created });
+            const result = await this.requestObject(url, data, parser, 'POST', true);
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to request web push: wrong response from API');
+            }
+            return re.created;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create web push: ', e);
+            }
+            throw e;
+        }
+    }
+    async getSessions(pagination) {
+        const queryString = new QueryString('/webpush');
+        queryString.addPagination(pagination);
+        const parser = (raw) => {
+            const session = new UserNotificationSession();
+            session.id = raw.id;
+            session.session = raw.session;
+            session.state = State.fromString(raw.state);
+            session.createdAt = raw.created_at;
+            session.updatedAt = raw.updated_at;
+            session.expiresAt = raw.expires_at;
+            session.os = raw.os;
+            session.browser = raw.browser;
+            return session;
+        };
+        const rawTriggers = await this.requestCollection(queryString, parser);
+        return rawTriggers;
+    }
+}

package/dist/Service/WorkspaceEndpoint.d.ts

@@ -0,0 +1,9 @@
+import { Endpoint } from './Endpoint.js';
+import { Workspace } from '../Model/Workspace/Workspace.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+export declare class WorkspaceEndpoint extends Endpoint {
+    getAll(pagination?: CursorPagination | null): Promise<CollectionResult<Workspace>>;
+    getById(workspaceId: string): Promise<Workspace | null>;
+    save(workspace: Workspace): Promise<Workspace>;
+}

package/dist/Service/WorkspaceEndpoint.js

@@ -0,0 +1,49 @@
+import { Endpoint } from './Endpoint.js';
+import { Workspace } from '../Model/Workspace/Workspace.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+export class WorkspaceEndpoint extends Endpoint {
+    async getAll(pagination = null) {
+        try {
+            const queryString = new QueryString('/workspaces');
+            queryString.addPagination(pagination);
+            const result = await this.requestCollection(queryString, Workspace.parse);
+            return result;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load workspaces: ' + e);
+            }
+            throw e;
+        }
+    }
+    async getById(workspaceId) {
+        try {
+            const url = '/workspaces/' + workspaceId + '';
+            const result = await this.requestObject(url, null, Workspace.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load workspace by id: ', error);
+            }
+            throw error;
+        }
+    }
+    async save(workspace) {
+        try {
+            const url = '/workspaces';
+            const result = await this.requestObject(url, workspace, Workspace.parse, 'POST');
+            const updatedWorkspace = result.getData();
+            if (updatedWorkspace === null) {
+                throw new Error('Workspace not updated');
+            }
+            return updatedWorkspace;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save workspace: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/WorkspaceMemberEndpoint.d.ts

@@ -0,0 +1,14 @@
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { WorkspaceMember } from '../Model/Workspace/WorkspaceMember.js';
+import { WorkspaceMemberInvite } from '../Model/Workspace/WorkspaceMemberInvite.js';
+import { WorkspaceMemberInvite2 } from '../Model/Workspace/WorkspaceMemberInvite2.js';
+import { WorkspaceMemberRole } from '../Model/Workspace/WorkspaceMemberRole.js';
+import { Endpoint } from './Endpoint.js';
+export declare class WorkspaceMemberEndpoint extends Endpoint {
+    getByWorkspace(workspaceId: string, pagination?: CursorPagination | null): Promise<CollectionResult<WorkspaceMember>>;
+    invite(workspaceId: string, invites: WorkspaceMemberInvite[]): Promise<boolean>;
+    getWorkspaceInviteByCode(inviteCode: string): Promise<WorkspaceMemberInvite2 | null>;
+    getRoles(workspaceId: string): Promise<CollectionResult<WorkspaceMemberRole>>;
+    saveMember(member: WorkspaceMember): Promise<WorkspaceMember>;
+}