@attlaz/client 1.77.1

package/dist/Model/Worker/PlatformImage.d.ts

@@ -0,0 +1,13 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class PlatformImage implements StateAware {
+    id: string;
+    platformId: string;
+    image: string;
+    name: string;
+    version: string;
+    languageVersion: string;
+    buildDate: Date;
+    state: State;
+    static parse(raw: any): PlatformImage;
+}

package/dist/Model/Worker/PlatformImage.js

@@ -0,0 +1,24 @@
+import { State } from '../State.js';
+import { Utils } from '../../Utils.js';
+export class PlatformImage {
+    id;
+    platformId;
+    image;
+    name;
+    version;
+    languageVersion;
+    buildDate;
+    state = State.Active;
+    static parse(raw) {
+        const platformImage = new PlatformImage();
+        platformImage.id = raw.id;
+        platformImage.platformId = raw.platform;
+        platformImage.name = raw.name;
+        platformImage.image = raw.image;
+        platformImage.version = raw.version;
+        platformImage.languageVersion = raw.language_version;
+        platformImage.buildDate = Utils.parseRawDate(raw.build_date);
+        platformImage.state = State.fromString(raw.state);
+        return platformImage;
+    }
+}

package/dist/Model/Workspace/Workspace.d.ts

@@ -0,0 +1,10 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Workspace extends MetaDataAware implements StateAware {
+    id: string;
+    key: string;
+    state: State;
+    static parse(raw: ApiRecord): Workspace;
+}

package/dist/Model/Workspace/Workspace.js

@@ -0,0 +1,14 @@
+import { State } from '../State.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+export class Workspace extends MetaDataAware {
+    id;
+    key;
+    state;
+    static parse(raw) {
+        const workspace = MetaDataAware.parseMetaData(new Workspace(), raw);
+        workspace.id = raw.id;
+        workspace.key = raw.key;
+        workspace.state = State.fromString(raw.state);
+        return workspace;
+    }
+}

package/dist/Model/Workspace/WorkspaceMember.d.ts

@@ -0,0 +1,14 @@
+import { State } from '../State.js';
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class WorkspaceMember {
+    id: string;
+    workspaceId: string;
+    email: string;
+    invite: boolean;
+    lastLoginAt: Date | null;
+    name: string;
+    roleId: string;
+    state: State | WorkspaceMemberInviteState;
+    static parse(rawMember: ApiRecord): WorkspaceMember;
+}

package/dist/Model/Workspace/WorkspaceMember.js

@@ -0,0 +1,32 @@
+import { State } from '../State.js';
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+import { Utils } from '../../Utils.js';
+export class WorkspaceMember {
+    id;
+    workspaceId;
+    email;
+    invite;
+    lastLoginAt = null;
+    name;
+    roleId;
+    state;
+    static parse(rawMember) {
+        const member = new WorkspaceMember();
+        member.id = rawMember.id;
+        member.workspaceId = rawMember.workspace;
+        member.email = rawMember.email;
+        member.invite = Utils.isTrue(rawMember.invite);
+        if (rawMember.last_login !== null && rawMember.last_login !== undefined) {
+            member.lastLoginAt = Utils.parseRawDate(rawMember.last_login);
+        }
+        member.name = rawMember.name;
+        member.roleId = rawMember.role;
+        if (member.invite) {
+            member.state = WorkspaceMemberInviteState.fromString(rawMember.state);
+        }
+        else {
+            member.state = State.fromString(rawMember.state);
+        }
+        return member;
+    }
+}

package/dist/Model/Workspace/WorkspaceMemberInvite.d.ts

@@ -0,0 +1,13 @@
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+export declare class WorkspaceMemberInvite {
+    id: string;
+    code: string;
+    workspaceId: string;
+    email: string;
+    role: string;
+    date: Date;
+    expiration: Date;
+    inviterId: string;
+    inviterEmail: string;
+    state: WorkspaceMemberInviteState;
+}

package/dist/Model/Workspace/WorkspaceMemberInvite.js

@@ -0,0 +1,13 @@
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+export class WorkspaceMemberInvite {
+    id;
+    code;
+    workspaceId;
+    email;
+    role;
+    date;
+    expiration;
+    inviterId;
+    inviterEmail;
+    state = WorkspaceMemberInviteState.Accepted;
+}

package/dist/Model/Workspace/WorkspaceMemberInvite2.d.ts

@@ -0,0 +1,10 @@
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+export declare class WorkspaceMemberInvite2 {
+    code: string;
+    email: string | null;
+    inviterName: string | null;
+    inviterEmail: string | null;
+    workspaceName: string | null;
+    state: WorkspaceMemberInviteState;
+    static parse(rawInvite: any): WorkspaceMemberInvite2;
+}

package/dist/Model/Workspace/WorkspaceMemberInvite2.js

@@ -0,0 +1,19 @@
+import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState.js';
+export class WorkspaceMemberInvite2 {
+    code;
+    email;
+    inviterName;
+    inviterEmail;
+    workspaceName;
+    state;
+    static parse(rawInvite) {
+        return {
+            code: rawInvite.code,
+            email: rawInvite.email,
+            inviterName: rawInvite.inviter_name,
+            inviterEmail: rawInvite.inviter_email,
+            workspaceName: rawInvite.workspace_name,
+            state: WorkspaceMemberInviteState.fromString(rawInvite.state),
+        };
+    }
+}

package/dist/Model/Workspace/WorkspaceMemberInviteState.d.ts

@@ -0,0 +1,11 @@
+export declare enum WorkspaceMemberInviteState {
+    Pending = "pending",
+    Declined = "declined",
+    Accepted = "accepted",
+    Revoked = "revoked",
+    Expired = "expired",
+    Removed = "removed"
+}
+export declare namespace WorkspaceMemberInviteState {
+    const fromString: (input: string) => WorkspaceMemberInviteState;
+}

package/dist/Model/Workspace/WorkspaceMemberInviteState.js

@@ -0,0 +1,19 @@
+import { Utils } from '../../Utils.js';
+export var WorkspaceMemberInviteState;
+(function (WorkspaceMemberInviteState) {
+    WorkspaceMemberInviteState["Pending"] = "pending";
+    WorkspaceMemberInviteState["Declined"] = "declined";
+    WorkspaceMemberInviteState["Accepted"] = "accepted";
+    WorkspaceMemberInviteState["Revoked"] = "revoked";
+    WorkspaceMemberInviteState["Expired"] = "expired";
+    WorkspaceMemberInviteState["Removed"] = "removed";
+})(WorkspaceMemberInviteState || (WorkspaceMemberInviteState = {}));
+(function (WorkspaceMemberInviteState) {
+    WorkspaceMemberInviteState.fromString = (input) => {
+        const result = Utils.parseEnum(input, WorkspaceMemberInviteState);
+        if (result === null) {
+            throw new Error('Unable to parse WorkspaceMemberInviteState from string: Unknown WorkspaceMemberInviteState "' + input + '"');
+        }
+        return result;
+    };
+})(WorkspaceMemberInviteState || (WorkspaceMemberInviteState = {}));

package/dist/Model/Workspace/WorkspaceMemberRole.d.ts

@@ -0,0 +1,4 @@
+export declare class WorkspaceMemberRole {
+    id: string;
+    name: string;
+}

package/dist/Model/Workspace/WorkspaceMemberRole.js

@@ -0,0 +1,4 @@
+export class WorkspaceMemberRole {
+    id;
+    name;
+}

package/dist/ResourceNamespace.d.ts

@@ -0,0 +1,2 @@
+export declare class ResourceNamespace {
+}

package/dist/ResourceNamespace.js

@@ -0,0 +1,2 @@
+export class ResourceNamespace {
+}

package/dist/Service/AccessTokenEndpoint.d.ts

@@ -0,0 +1,11 @@
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { UserAccessToken } from '../Model/AccessToken/UserAccessToken.js';
+import { UserAccessTokenStatus } from '../Model/AccessToken/UserAccessTokenStatus.js';
+import { Endpoint } from './Endpoint.js';
+export declare class AccessTokenEndpoint extends Endpoint {
+    getByUser(pagination: CursorPagination, status?: UserAccessTokenStatus | null): Promise<CollectionResult<UserAccessToken>>;
+    create(name: string, scopes: string[], expiresAt: Date): Promise<UserAccessToken>;
+    update(tokenId: string, name: string, scopes: string[]): Promise<UserAccessToken>;
+    revoke(tokenId: string): Promise<boolean>;
+}

package/dist/Service/AccessTokenEndpoint.js

@@ -0,0 +1,82 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { UserAccessToken } from '../Model/AccessToken/UserAccessToken.js';
+import { Endpoint } from './Endpoint.js';
+export class AccessTokenEndpoint extends Endpoint {
+    async getByUser(pagination, status = null) {
+        const queryString = new QueryString('/access-tokens');
+        queryString.addPagination(pagination);
+        if (status !== null) {
+            queryString.set('status', status);
+        }
+        try {
+            const result = await this.requestCollection(queryString, UserAccessToken.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load user access tokens: ', error);
+            }
+            throw error;
+        }
+    }
+    async create(name, scopes, expiresAt) {
+        try {
+            const url = '/access-tokens';
+            const data = {
+                name,
+                scopes,
+                expires_at: expiresAt,
+            };
+            const result = await this.requestObject(url, data, UserAccessToken.parse, 'POST');
+            const createdToken = result.getData();
+            if (createdToken === null) {
+                throw new Error('Unable to create token: wrong response from API');
+            }
+            return createdToken;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save token: ', ex);
+            }
+            throw ex;
+        }
+    }
+    async update(tokenId, name, scopes) {
+        try {
+            const url = '/access-tokens/' + tokenId;
+            const result = await this.requestObject(url, {
+                name, scopes,
+            }, UserAccessToken.parse, 'POST');
+            const updatedToken = result.getData();
+            if (updatedToken === null) {
+                throw new Error('Unable to create token: wrong response from API');
+            }
+            return updatedToken;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save token: ', ex);
+            }
+            throw ex;
+        }
+    }
+    async revoke(tokenId) {
+        try {
+            const url = '/access-tokens/' + tokenId;
+            const parser = (raw) => ({ revoked: raw.revoked });
+            const result = await this.requestObject(url, null, parser, 'DELETE');
+            const res = result.getData();
+            if (res === null) {
+                console.log('Token delete item wrong data', { result, parsed: res });
+                throw new Error('Unable to revoke token: wrong response from API');
+            }
+            return res.revoked;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to revoke token: ', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/AdapterConnectionEndpoint.d.ts

@@ -0,0 +1,28 @@
+import { AdapterConnection } from '../Model/Adapter/AdapterConnection.js';
+import { TestConnectionResult } from '../Model/Adapter/TestConnectionResult.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { AdapterConnectionConfigurationValue } from '../Model/Adapter/AdapterConnectionConfigurationValue.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { AdapterConnectionEvent } from '../Model/Adapter/AdapterConnectionEvent.js';
+import { Endpoint } from './Endpoint.js';
+export declare class AdapterConnectionEndpoint extends Endpoint {
+    getConnections(projectId: string, pagination: CursorPagination): Promise<CollectionResult<AdapterConnection>>;
+    getConnectionById(connectionId: string): Promise<AdapterConnection | null>;
+    getConnectionByKey(projectId: string, connectionKey: string): Promise<AdapterConnection | null>;
+    getConnectionConfiguration(connectionId: string): Promise<CollectionResult<AdapterConnectionConfigurationValue>>;
+    saveConnection(projectId: string, connection: AdapterConnection): Promise<AdapterConnection>;
+    saveConnectionConfiguration(connectionId: string, configuration: AdapterConnectionConfigurationValue[]): Promise<boolean>;
+    getConnectionEvents(connectionId: string, pagination: CursorPagination): Promise<CollectionResult<AdapterConnectionEvent>>;
+    /**
+     * Test an adapter connection end-to-end via Services-Api.
+     *
+     * Runs schema validation first (config completeness) and then invokes the
+     * adapter's `testConnection()` probe. The returned result has a per-check
+     * breakdown so the UI can render a step-by-step view; the overall `state`
+     * is the worst of the per-check states (skipped < passed < warning < failed).
+     *
+     * Used by the Web App's "Test" button. Replaces the legacy
+     * `POST /connections/:id/check` route on Core-Api (removed).
+     */
+    testConnection(connectionId: string): Promise<TestConnectionResult>;
+}

package/dist/Service/AdapterConnectionEndpoint.js

@@ -0,0 +1,124 @@
+import { AdapterConnection } from '../Model/Adapter/AdapterConnection.js';
+import { parseTestConnectionResult } from '../Model/Adapter/TestConnectionResult.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { AdapterConnectionEvent } from '../Model/Adapter/AdapterConnectionEvent.js';
+import { Endpoint } from './Endpoint.js';
+export class AdapterConnectionEndpoint extends Endpoint {
+    async getConnections(projectId, pagination) {
+        try {
+            const queryString = new QueryString('/projects/' + projectId + '/connections');
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, AdapterConnection.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapters: ', error);
+            }
+            throw error;
+        }
+    }
+    async getConnectionById(connectionId) {
+        try {
+            const url = '/connections/' + connectionId;
+            const result = await this.requestObject(url, null, AdapterConnection.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load connection: ', error);
+            }
+            throw error;
+        }
+    }
+    async getConnectionByKey(projectId, connectionKey) {
+        try {
+            const url = '/projects/' + projectId + '/connections/' + connectionKey;
+            const result = await this.requestObject(url, null, AdapterConnection.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load connection: ', error);
+            }
+            throw error;
+        }
+    }
+    async getConnectionConfiguration(connectionId) {
+        try {
+            const url = '/connections/' + connectionId + '/configuration';
+            const parser = (raw) => ({
+                id: raw.id,
+                adapterConnectionId: raw.adapter_connection,
+                configurationId: raw.configuration,
+                value: raw.value,
+            });
+            return await this.requestCollection(url, parser);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load connection: ', error);
+            }
+            throw error;
+        }
+    }
+    async saveConnection(projectId, connection) {
+        try {
+            const url = '/projects/' + projectId + '/connections';
+            const result = await this.requestObject(url, connection, AdapterConnection.parse, 'POST');
+            const updatedAdapterConnection = result.getData();
+            if (updatedAdapterConnection === null) {
+                throw new Error('AdapterConnection not updated');
+            }
+            return updatedAdapterConnection;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save connection: ', error);
+            }
+            throw error;
+        }
+    }
+    async saveConnectionConfiguration(connectionId, configuration) {
+        try {
+            const url = '/connections/' + connectionId + '/configuration';
+            const parser = (raw) => ({ saved: raw.saved });
+            const result = await this.requestObject(url, { configuration: configuration }, parser, 'POST');
+            const res = result.getData();
+            if (res === null) {
+                throw new Error('Unable to save connection configuration: wrong response from API');
+            }
+            return res.saved;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save connection: ', error);
+            }
+            throw error;
+        }
+    }
+    async getConnectionEvents(connectionId, pagination) {
+        const queryString = new QueryString('/adapters/connections/' + connectionId + '/events');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, AdapterConnectionEvent.parse);
+    }
+    /**
+     * Test an adapter connection end-to-end via Services-Api.
+     *
+     * Runs schema validation first (config completeness) and then invokes the
+     * adapter's `testConnection()` probe. The returned result has a per-check
+     * breakdown so the UI can render a step-by-step view; the overall `state`
+     * is the worst of the per-check states (skipped < passed < warning < failed).
+     *
+     * Used by the Web App's "Test" button. Replaces the legacy
+     * `POST /connections/:id/check` route on Core-Api (removed).
+     */
+    async testConnection(connectionId) {
+        const url = '/services/' + connectionId + '/test-connection';
+        const result = await this.requestObject(url, null, parseTestConnectionResult, 'POST');
+        const data = result.getData();
+        if (data === null) {
+            return { state: 'skipped', checks: [], error: 'Empty response from test endpoint' };
+        }
+        return data;
+    }
+}

package/dist/Service/AdapterEndpoint.d.ts

@@ -0,0 +1,12 @@
+import { Adapter } from '../Model/Adapter/Adapter.js';
+import { AdapterConfiguration } from '../Model/Adapter/AdapterConfiguration.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { AdapterCategory } from '../Model/Adapter/AdapterCategory.js';
+import { Endpoint } from './Endpoint.js';
+export declare class AdapterEndpoint extends Endpoint {
+    getAdapters(pagination?: CursorPagination | null, withMedia?: boolean): Promise<CollectionResult<Adapter>>;
+    getAdapter(adapterId: string, withMedia?: boolean): Promise<Adapter | null>;
+    getAdapterConfiguration(adapterId: string): Promise<CollectionResult<AdapterConfiguration>>;
+    getAdapterCategories(pagination: CursorPagination): Promise<CollectionResult<AdapterCategory>>;
+}

package/dist/Service/AdapterEndpoint.js

@@ -0,0 +1,64 @@
+import { Adapter } from '../Model/Adapter/Adapter.js';
+import { AdapterConfiguration } from '../Model/Adapter/AdapterConfiguration.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { AdapterCategory } from '../Model/Adapter/AdapterCategory.js';
+import { Endpoint } from './Endpoint.js';
+export class AdapterEndpoint extends Endpoint {
+    async getAdapters(pagination = null, withMedia = false) {
+        try {
+            const queryString = new QueryString('/adapters');
+            queryString.addPagination(pagination);
+            if (withMedia) {
+                queryString.set('with-media', true);
+            }
+            return await this.requestCollection(queryString, Adapter.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapters: ', error);
+            }
+            throw error;
+        }
+    }
+    async getAdapter(adapterId, withMedia = false) {
+        try {
+            const queryString = new QueryString('/adapters/' + adapterId);
+            if (withMedia) {
+                queryString.set('with-media', true);
+            }
+            const result = await this.requestObject(queryString, null, Adapter.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter by id: ', error);
+            }
+            throw error;
+        }
+    }
+    async getAdapterConfiguration(adapterId) {
+        try {
+            const url = '/adapters/' + adapterId + '/configuration';
+            return await this.requestCollection(url, AdapterConfiguration.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter configuration: ', error);
+            }
+            throw error;
+        }
+    }
+    async getAdapterCategories(pagination) {
+        try {
+            const queryString = new QueryString('/adapter-categories');
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, AdapterCategory.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load adapter categories: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/ChannelEndpoint.d.ts

@@ -0,0 +1,13 @@
+import { Channel } from '../Model/Messaging/Channel/Channel.js';
+import { ChannelHistory } from '../Model/Messaging/ChannelHistory.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ChannelEndpoint extends Endpoint {
+    getById(channelId: string): Promise<Channel | null>;
+    getByWorkspace(workspaceId: string, pagination?: CursorPagination | null): Promise<CollectionResult<Channel>>;
+    getByOwner(pagination?: CursorPagination | null): Promise<CollectionResult<Channel>>;
+    getMessages(channelId: string, pagination?: CursorPagination | null): Promise<CollectionResult<ChannelHistory>>;
+    save(subscriberChannel: Channel): Promise<Channel>;
+    testChannel(subscriberChannel: Channel): Promise<boolean>;
+}