@attlaz/client 1.77.1

package/dist/Service/Endpoint.js

@@ -0,0 +1,185 @@
+import { ClientError } from '../Http/ClientError.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+import { ApiError } from '../Model/Error/ApiError.js';
+import { LogStreamId } from '../Model/Log/LogStreamId.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { ObjectResult } from '../Model/Result/ObjectResult.js';
+import { ObjectWrapper } from '../Model/Result/ObjectWrapper.js';
+import { Utils } from '../Utils.js';
+export class Endpoint {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    formatParameters(data = null) {
+        if (data === null || data === undefined) {
+            return null;
+        }
+        if (Array.isArray(data)) {
+            const result = [];
+            for (const value of data) {
+                result.push(this.formatParameters(value));
+            }
+            return result;
+        }
+        if (Utils.isDate(data)) {
+            return data.toISOString();
+        }
+        if (typeof data === 'object') {
+            // These types need recursive formatting applied to their serialized output.
+            if (data instanceof DataValueCollection || data instanceof LogStreamId) {
+                return this.formatParameters(data.jsonSerialize());
+            }
+            if (data instanceof QueryString) {
+                return data.getParameters();
+            }
+            // Duck-type check for JsonSerializable: avoids fragile instanceof checks across
+            // ESM module boundaries where class identity can differ between realms.
+            if (typeof data.jsonSerialize === 'function') {
+                return data.jsonSerialize();
+            }
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                const formattedKey = this.formatKey(key);
+                result[formattedKey] = this.formatParameters(value);
+            }
+            return result;
+        }
+        return data;
+    }
+    formatKey(key) {
+        let formattedKey = key.replace(/([A-Z])/g, ' $1');
+        formattedKey = formattedKey.split(' ').join('_').toLowerCase();
+        // Intentional: the API expects bare resource names, not ID-suffixed ones.
+        // e.g. TypeScript `environmentId` → snake_case `environment_id` → API param `environment`
+        if (formattedKey.endsWith('_id')) {
+            formattedKey = formattedKey.substring(0, formattedKey.length - '_id'.length);
+        }
+        // Intentional: same convention for plural IDs.
+        // e.g. `categoryIds` → `category_ids` → `categorys` (TODO: handle irregular plurals properly)
+        if (formattedKey.endsWith('_ids')) {
+            formattedKey = formattedKey.substring(0, formattedKey.length - '_ids'.length) + 's';
+        }
+        return formattedKey;
+    }
+    async requestCollection(action, parser, parameters = null, method = 'GET', signWithOauthToken = true) {
+        parameters = this.formatParameters(parameters);
+        if (action instanceof QueryString) {
+            action = action.build();
+        }
+        let requestResponse;
+        try {
+            requestResponse = await this.httpClient.request(action, parameters, method, signWithOauthToken);
+        }
+        catch (error) {
+            throw this.toApiError(error);
+        }
+        const result = new CollectionResult();
+        /**
+         * Parse data
+         */
+        if (requestResponse === null || requestResponse === undefined) {
+            throw new Error('Unable to parse collection: response is empty for action `[' + method + '] ' + action + '`');
+        }
+        if (!Object.prototype.hasOwnProperty.call(requestResponse, 'data') || requestResponse.data === undefined) {
+            throw new Error('Unable to parse collection: data is not defined in response from action `[' + method + '] ' + action + '`');
+        }
+        if (!Object.prototype.hasOwnProperty.call(requestResponse, 'has_more') || requestResponse.has_more === undefined) {
+            throw new Error('Unable to parse collection: hasMore is not defined in response from action `[' + method + '] ' + action + '`');
+        }
+        const hasMore = Utils.isTrue(requestResponse.has_more);
+        result.setData(this.parseCollection(requestResponse.data, parser), hasMore);
+        return result;
+    }
+    async requestObject(action, parameters = null, parser, method = 'GET', signWithOauthToken = true) {
+        parameters = this.formatParameters(parameters);
+        if (action instanceof QueryString) {
+            action = action.build();
+        }
+        const result = new ObjectResult();
+        let requestResponse;
+        try {
+            requestResponse = await this.httpClient.request(action, parameters, method, signWithOauthToken);
+        }
+        catch (error) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
+                result.setData(null);
+                return result;
+            }
+            throw this.toApiError(error);
+        }
+        // TODO: add errors
+        /**
+         * Parse errors
+         */
+        if (requestResponse === null || requestResponse === undefined) {
+            throw new ApiError('Unable to parse object: response is empty for action `[' + method + '] ' + action + '`', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+        }
+        result.setData(this.parseObject(requestResponse, parser));
+        return result;
+    }
+    toApiError(error) {
+        if (error instanceof ClientError) {
+            const apiError = new ApiError(error.message, error.httpStatus);
+            if (error.response !== null && error.response !== undefined) {
+                const response = error.response;
+                if (response.data !== null && response.data !== undefined && response.data.error !== undefined) {
+                    if (response.data.error.type !== undefined) {
+                        apiError.type = response.data.error.type;
+                    }
+                    if (response.data.error.code !== undefined) {
+                        apiError.code = response.data.error.code;
+                    }
+                    if (response.data.error.message !== undefined) {
+                        apiError.message = response.data.error.message;
+                    }
+                    if (response.data.error.param !== undefined) {
+                        apiError.param = response.data.error.param;
+                    }
+                }
+            }
+            return apiError;
+        }
+        if (this.httpClient.isDebugEnabled()) {
+            console.error('Unrecognised error type (not a ClientError)', { error });
+        }
+        return new ApiError('Unknown Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+    }
+    parseCollection(rawData, parser) {
+        const data = [];
+        if (!Array.isArray(rawData)) {
+            throw new Error('Invalid data');
+        }
+        for (const rawDataEntry of rawData) {
+            const parsedObject = this.parseObject(rawDataEntry, parser);
+            if (parsedObject !== null) {
+                data.push(parsedObject);
+            }
+        }
+        return data;
+    }
+    parseObject(rawObject, parser) {
+        // Parse the raw object directly by default. With debug enabled the object is wrapped so
+        // that reads of properties the response doesn't contain get reported — useful for spotting
+        // schema drift, but too noisy (and a per-object Proxy cost) to run normally.
+        // Enable via client.getHttpClient().enableDebug().
+        const data = this.httpClient.isDebugEnabled() ? ObjectWrapper.wrap(rawObject) : rawObject;
+        try {
+            return parser(data);
+        }
+        catch (error) {
+            // Report through the transport's parse-error handler (defaults to console.error;
+            // consumers can route it to a logger / error tracker via Client.setParseErrorHandler).
+            this.httpClient.reportParseError('Unable to parse object', { object: rawObject, error });
+            // In debug, surface schema drift loudly (dev/tests) by rethrowing. In production,
+            // degrade gracefully — return null so the caller skips the row / shows a not-found
+            // state, and a single unparseable object never breaks an entire view.
+            if (this.httpClient.isDebugEnabled()) {
+                throw error;
+            }
+        }
+        return null;
+    }
+}

package/dist/Service/FirewallEndpoint.d.ts

@@ -0,0 +1,29 @@
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export type BlockedIp = {
+    id: string;
+    ip: string;
+    from: Date;
+    to: Date;
+    reason: string;
+};
+export type FlaggedIp = {
+    id: string;
+    ip: string;
+    date: Date;
+    reason: string;
+};
+export type IpRule = {
+    id: string;
+    ip: string;
+    action: string;
+    description: string;
+};
+export declare class FirewallEndpoint extends Endpoint {
+    getBlockedIps(pagination: CursorPagination): Promise<CollectionResult<BlockedIp>>;
+    getFlaggedIps(pagination: CursorPagination): Promise<CollectionResult<FlaggedIp>>;
+    getIpRules(pagination: CursorPagination): Promise<CollectionResult<IpRule>>;
+    createIpRule(ip: string, action: string, description?: string): Promise<boolean>;
+    unblockIP(ip: string): Promise<boolean>;
+}

package/dist/Service/FirewallEndpoint.js

@@ -0,0 +1,88 @@
+import { Utils } from '../Utils.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class FirewallEndpoint extends Endpoint {
+    async getBlockedIps(pagination) {
+        const parser = (raw) => {
+            return {
+                id: raw.id,
+                ip: raw.ip,
+                from: Utils.parseRawDate(raw.from),
+                to: Utils.parseRawDate(raw.to),
+                reason: raw.reason,
+            };
+        };
+        const queryString = new QueryString('/system/firewall/blocked');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, parser);
+        return result;
+    }
+    async getFlaggedIps(pagination) {
+        const parser = (raw) => {
+            return {
+                id: raw.id,
+                ip: raw.ip,
+                date: Utils.parseRawDate(raw.date),
+                reason: raw.reason,
+            };
+        };
+        const queryString = new QueryString('/system/firewall/flagged');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, parser);
+        return result;
+    }
+    async getIpRules(pagination) {
+        const parser = (raw) => {
+            return {
+                id: raw.id,
+                ip: raw.ip,
+                action: raw.action,
+                description: raw.description,
+            };
+        };
+        const queryString = new QueryString('/system/firewall/rules');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, parser);
+        return result;
+    }
+    async createIpRule(ip, action, description = '') {
+        const cmd = '/system/firewall/ip_rules';
+        try {
+            const parser = (raw) => raw.success;
+            const result = await this.requestObject(cmd, {
+                ip, action, description,
+            }, parser, 'PUT');
+            const re = result.getData();
+            if (re === null) {
+                console.log('createIPRule wrong result', { result, parsed: re });
+                throw new Error('Unable to create IP rule: wrong response from API');
+            }
+            return re.success;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create IP rule', ex);
+            }
+            throw ex;
+        }
+    }
+    async unblockIP(ip) {
+        const cmd = '/system/firewall/blocked_ips';
+        try {
+            const parser = (raw) => ({ success: raw.success });
+            const result = await this.requestObject(cmd, { ip }, parser, 'DELETE');
+            const x = result.getData();
+            if (x === null) {
+                console.log('Unblock ip wrong response', { result, parsed: x });
+                throw new Error('Unable to unblock ip: wrong response from API');
+            }
+            return x.success;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Unable to unblock ip', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/FlowEndpoint.d.ts

@@ -0,0 +1,12 @@
+import { Flow } from '../Model/Flow/Flow.js';
+import { FlowSummary } from '../Model/Flow/FlowSummary.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class FlowEndpoint extends Endpoint {
+    getByProject(projectId: string, pagination: CursorPagination): Promise<CollectionResult<Flow>>;
+    getById(flowId: string): Promise<Flow | null>;
+    getFlowSummaries(projectId: string, projectEnvironmentId?: string | null, pagination?: CursorPagination | null): Promise<CollectionResult<FlowSummary>>;
+    getFlowSummary(flowId: string, projectEnvironmentId?: string | null): Promise<FlowSummary | null>;
+    save(flow: Flow): Promise<Flow>;
+}

package/dist/Service/FlowEndpoint.js

@@ -0,0 +1,84 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
+import { Flow } from '../Model/Flow/Flow.js';
+import { FlowSummary } from '../Model/Flow/FlowSummary.js';
+import { Utils } from '../Utils.js';
+import { Endpoint } from './Endpoint.js';
+export class FlowEndpoint extends Endpoint {
+    async getByProject(projectId, pagination) {
+        try {
+            const queryString = new QueryString('/projects/' + projectId + '/flows');
+            queryString.addPagination(pagination);
+            const result = await this.requestCollection(queryString, Flow.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to get projects: ', error);
+            }
+            throw error;
+        }
+    }
+    async getById(flowId) {
+        try {
+            const result = await this.requestObject('/flows/' + flowId, null, Flow.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
+                return null;
+            }
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load flows: ' + error);
+            }
+            throw error;
+        }
+    }
+    async getFlowSummaries(projectId, projectEnvironmentId = null, pagination = null) {
+        let parameters = null;
+        if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+            parameters = { environment: projectEnvironmentId };
+        }
+        const queryString = new QueryString('projects/' + projectId + '/flowsummaries');
+        if (pagination !== null) {
+            queryString.addPagination(pagination);
+        }
+        return await this.requestCollection(queryString, FlowSummary.parse, parameters);
+    }
+    async getFlowSummary(flowId, projectEnvironmentId = null) {
+        let parameters = null;
+        if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+            parameters = { environment: projectEnvironmentId };
+        }
+        try {
+            const rawFlowSummaries = await this.requestObject('flows/' + flowId + '/summaries', parameters, FlowSummary.parse);
+            if (rawFlowSummaries.getData() === null) {
+                return null;
+            }
+            return rawFlowSummaries.getData();
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load flow by id ' + flowId + ': ' + e);
+            }
+            throw e;
+        }
+    }
+    async save(flow) {
+        try {
+            const url = '/projects/' + flow.projectId + '/flows';
+            const result = await this.requestObject(url, flow, Flow.parse, 'POST');
+            const updatedFlow = result.getData();
+            if (updatedFlow === null) {
+                throw new Error('Flow not updated');
+            }
+            return updatedFlow;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save flow: ', e);
+            }
+            throw e;
+        }
+    }
+}

package/dist/Service/FlowRunEndpoint.d.ts

@@ -0,0 +1,21 @@
+import { FlowRun } from '../Model/Flow/FlowRun.js';
+import { FlowRunStatus } from '../Model/Flow/FlowRunStatus.js';
+import { FlowRunSummary } from '../Model/Flow/FlowRunSummary.js';
+import { FlowRunHistory } from '../Model/Flow/FlowRunHistory.js';
+import { FlowRunLifecycle } from '../Model/Flow/FlowRunLifecycle.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class FlowRunEndpoint extends Endpoint {
+    getFlowRuns(flowId: string): Promise<CollectionResult<FlowRun>>;
+    getFlowRunSummaries(flowId: string, flowRunStatuses?: FlowRunStatus[] | null, pagination?: CursorPagination | null, projectEnvironmentId?: string | null): Promise<CollectionResult<FlowRunSummary>>;
+    getFlowRunSummary(flowRunId: string): Promise<FlowRunSummary | null>;
+    getFlowRunHistory(flowRunId: string): Promise<CollectionResult<FlowRunHistory>>;
+    /**
+     * Authoritative lifecycle (status derived from history, first-terminal-wins). Prefer this over
+     * getFlowRunSummary for control-flow decisions (e.g. the worker tombstone), since the summary
+     * reflects the eventually-consistent index projection which can lag the history.
+     */
+    getFlowRunLifecycle(flowRunId: string): Promise<FlowRunLifecycle | null>;
+    updateFlowRun(flowRunId: string, status: FlowRunStatus, time?: Date | null): Promise<FlowRun>;
+}

package/dist/Service/FlowRunEndpoint.js

@@ -0,0 +1,93 @@
+import { FlowRun } from '../Model/Flow/FlowRun.js';
+import { FlowRunSummary } from '../Model/Flow/FlowRunSummary.js';
+import { FlowRunHistory } from '../Model/Flow/FlowRunHistory.js';
+import { FlowRunLifecycle } from '../Model/Flow/FlowRunLifecycle.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class FlowRunEndpoint extends Endpoint {
+    async getFlowRuns(flowId) {
+        const result = await this.requestCollection('/flows/' + flowId + '/runs', FlowRun.parse);
+        return result;
+    }
+    async getFlowRunSummaries(flowId, flowRunStatuses = null, pagination = null, projectEnvironmentId = null) {
+        try {
+            const queryString = new QueryString('/flows/' + flowId + '/runsummaries');
+            queryString.addPagination(pagination);
+            // if (from !== null && from !== undefined) {
+            //
+            //     params = {};
+            //
+            //     params.from = from.toISOString();
+            // }
+            // if (to !== null && to !== undefined) {
+            //     if (params === null || params === undefined) {
+            //         params = {};
+            //     }
+            //     params.to = to.toISOString();
+            // }
+            if (projectEnvironmentId !== null && projectEnvironmentId !== undefined && projectEnvironmentId !== '') {
+                queryString.set('environment', projectEnvironmentId);
+            }
+            if (flowRunStatuses !== null && flowRunStatuses !== undefined && flowRunStatuses.length > 0) {
+                queryString.set('statuses', flowRunStatuses.map((status) => status.toString()));
+            }
+            // if (flowRunStatuses !== null && flowRunStatuses.length > 0) {
+            //     if (params === null || params === undefined) {
+            //         params = {};
+            //     }
+            //     params.statuses = flowRunStatuses;
+            // }
+            const result = await this.requestCollection(queryString.build(), FlowRunSummary.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load flow runs: ' + error);
+            }
+            throw error;
+        }
+    }
+    async getFlowRunSummary(flowRunId) {
+        try {
+            const result = await this.requestObject('/flowruns/' + flowRunId + '/summaries', null, FlowRunSummary.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load flow runs: ' + error);
+            }
+            throw error;
+        }
+    }
+    async getFlowRunHistory(flowRunId) {
+        const result = await this.requestCollection('/flowruns/' + flowRunId + '/history', FlowRunHistory.parse);
+        return result;
+    }
+    /**
+     * Authoritative lifecycle (status derived from history, first-terminal-wins). Prefer this over
+     * getFlowRunSummary for control-flow decisions (e.g. the worker tombstone), since the summary
+     * reflects the eventually-consistent index projection which can lag the history.
+     */
+    async getFlowRunLifecycle(flowRunId) {
+        const result = await this.requestObject('/flowruns/' + flowRunId + '/lifecycle', null, FlowRunLifecycle.parse);
+        return result.getData();
+    }
+    async updateFlowRun(flowRunId, status, time = null) {
+        if (flowRunId.length === 0) {
+            throw new Error('Flow run id cannot be empty');
+        }
+        const params = {};
+        if (status !== null && status !== undefined) {
+            params.status = status;
+        }
+        if (time !== null && time !== undefined) {
+            params.time = time;
+        }
+        const result = await this.requestObject('/flowruns/' + flowRunId + '', params, FlowRun.parse, 'POST');
+        const updatedFlowRun = result.getData();
+        if (updatedFlowRun === null) {
+            throw new Error('FlowRun not updated');
+        }
+        return updatedFlowRun;
+    }
+}

package/dist/Service/FlowRunRequestEndpoint.d.ts

@@ -0,0 +1,6 @@
+import { FlowRunResponse } from '../Model/Flow/FlowRunResponse.js';
+import { Parameters } from '../Http/Data/Parameters.js';
+import { Endpoint } from './Endpoint.js';
+export declare class FlowRunRequestEndpoint extends Endpoint {
+    requestFlowRun(flowId: string, params: Parameters, wait?: boolean): Promise<FlowRunResponse>;
+}

package/dist/Service/FlowRunRequestEndpoint.js

@@ -0,0 +1,32 @@
+import { FlowRunResponse } from '../Model/Flow/FlowRunResponse.js';
+import { Endpoint } from './Endpoint.js';
+export class FlowRunRequestEndpoint extends Endpoint {
+    async requestFlowRun(flowId, params, wait = false) {
+        let url = '/flows/' + flowId + '/flowrunrequests';
+        if (wait) {
+            url += '?wait=true';
+        }
+        try {
+            const parser = (raw) => {
+                const flowRunResponse = new FlowRunResponse();
+                flowRunResponse.flowRunRequestId = raw.flow_run_request;
+                flowRunResponse.result = raw.result;
+                flowRunResponse.success = raw.success;
+                return flowRunResponse;
+            };
+            const result = await this.requestObject(url, params, parser, 'POST');
+            // console.log('TODO: parse postTaskExecutionRequest result', result);
+            const postedFlowRunResponse = result.getData();
+            if (postedFlowRunResponse === null) {
+                throw new Error('FlowRunResponse not updated');
+            }
+            return postedFlowRunResponse;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to request flow run: ', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/FlowRunStatsEndpoint.d.ts

@@ -0,0 +1,5 @@
+import { FlowRunStats } from '../Model/Flow/FlowRunStats.js';
+import { Endpoint } from './Endpoint.js';
+export declare class FlowRunStatsEndpoint extends Endpoint {
+    create(flowRunStats: FlowRunStats): Promise<FlowRunStats>;
+}

package/dist/Service/FlowRunStatsEndpoint.js

@@ -0,0 +1,21 @@
+import { FlowRunStats } from '../Model/Flow/FlowRunStats.js';
+import { Endpoint } from './Endpoint.js';
+export class FlowRunStatsEndpoint extends Endpoint {
+    async create(flowRunStats) {
+        const url = '/flowruns/' + flowRunStats.flowRunId + '/stats';
+        try {
+            const result = await this.requestObject(url, flowRunStats, FlowRunStats.parse, 'POST');
+            const createdFlowRunStat = result.getData();
+            if (createdFlowRunStat === null) {
+                throw new Error('Unable to create stats: wrong response from API');
+            }
+            return createdFlowRunStat;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create flow run stats: ', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/HealthAlertEndpoint.d.ts

@@ -0,0 +1,13 @@
+import { EntityType } from '../Model/EntityType.js';
+import { HealthAlert } from '../Model/HealthAlert/HealthAlert.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class HealthAlertEndpoint extends Endpoint {
+    getCurrentAlertsByScope(scopeType: EntityType, scopeId: string): Promise<CollectionResult<HealthAlert>>;
+    /**
+     * Fetch all current alerts under a parent scope (today: only ProjectEnvironment).
+     * One query returns env-direct, pool-direct, and flow-direct alerts in a single round-trip
+     * — replaces the old N-call multi-scope loop on env-overview pages.
+     */
+    getCurrentAlertsByParentScope(parentScopeType: EntityType, parentScopeId: string): Promise<CollectionResult<HealthAlert>>;
+}

package/dist/Service/HealthAlertEndpoint.js

@@ -0,0 +1,36 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { HealthAlert } from '../Model/HealthAlert/HealthAlert.js';
+import { Endpoint } from './Endpoint.js';
+export class HealthAlertEndpoint extends Endpoint {
+    async getCurrentAlertsByScope(scopeType, scopeId) {
+        try {
+            const q = new QueryString('/health/' + scopeType + '/' + scopeId);
+            const result = await this.requestCollection(q, HealthAlert.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load health alerts: ', error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Fetch all current alerts under a parent scope (today: only ProjectEnvironment).
+     * One query returns env-direct, pool-direct, and flow-direct alerts in a single round-trip
+     * — replaces the old N-call multi-scope loop on env-overview pages.
+     */
+    async getCurrentAlertsByParentScope(parentScopeType, parentScopeId) {
+        try {
+            const q = new QueryString('/health/by-parent/' + parentScopeType + '/' + parentScopeId);
+            const result = await this.requestCollection(q, HealthAlert.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load health alerts by parent scope: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/InboxEndpoint.d.ts

@@ -0,0 +1,8 @@
+import { Endpoint } from './Endpoint.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { InboxMessage } from '../Model/Inbox/InboxMessage.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+export declare class InboxEndpoint extends Endpoint {
+    getAll(pagination?: CursorPagination | null, unacknowledgedOnly?: boolean): Promise<CollectionResult<InboxMessage>>;
+    save(message: InboxMessage): Promise<InboxMessage>;
+}