@attlaz/client 1.77.1

package/dist/Model/Inbox/InboxMessage.js

@@ -0,0 +1,21 @@
+import { Utils } from '../../Utils.js';
+export class InboxMessage {
+    id;
+    userId;
+    type;
+    subject;
+    body;
+    time;
+    acknowledged = false;
+    static parse(rawNotification) {
+        const inboxMessage = new InboxMessage();
+        inboxMessage.id = rawNotification.id;
+        inboxMessage.userId = rawNotification.user;
+        inboxMessage.type = rawNotification.type;
+        inboxMessage.subject = rawNotification.subject;
+        inboxMessage.body = rawNotification.body;
+        inboxMessage.time = Utils.parseRawDate(rawNotification.time);
+        inboxMessage.acknowledged = Utils.isTrue(rawNotification.acknowledged);
+        return inboxMessage;
+    }
+}

package/dist/Model/Infrastructure/RunnerPool.d.ts

@@ -0,0 +1,39 @@
+import { State } from '../State.js';
+export declare class RunnerPool {
+    id: string;
+    name: string;
+    environment: string;
+    queueIdentifier: string;
+    deploymentIdentifier: string;
+    type: QueueSpecificationType;
+    configuration: RunnerPoolConfiguration;
+    state: State;
+    static parse(raw: any): RunnerPool;
+    /**
+     * Coerce a raw wire value into a ResolvedValue<T> envelope. Accepts `{value, source}`
+     * as-is; falls back to `{value: defaultValue, source: null}` when the input is null,
+     * undefined, or missing the envelope shape, and appends the field name to `missing`
+     * so the caller can log a single batched warning. The `value` itself isn't type-
+     * validated — if T is `string | null` and the server sends a number, that's a
+     * server-side bug, not something this layer can fix.
+     */
+    private static parseResolved;
+}
+export type QueueSpecificationType = 'flow_run';
+export type ConfigurationSource = 'RunnerPool' | 'ProjectEnvironment' | 'Workspace' | 'Zone';
+export interface ResolvedValue<T> {
+    value: T;
+    source: ConfigurationSource | null;
+}
+export interface RunnerPoolConfiguration {
+    enabled: ResolvedValue<boolean>;
+    minRunners: ResolvedValue<number>;
+    maxRunners: ResolvedValue<number>;
+    cpuLimit: ResolvedValue<number | null>;
+    memoryLimit: ResolvedValue<number | null>;
+    imageId: ResolvedValue<string | null>;
+    runnerEndpoint: ResolvedValue<string | null>;
+    runnerTokenId: ResolvedValue<string | null>;
+    codeEndpoint: ResolvedValue<string | null>;
+    codeTokenId: ResolvedValue<string | null>;
+}

package/dist/Model/Infrastructure/RunnerPool.js

@@ -0,0 +1,77 @@
+import { State } from '../State.js';
+export class RunnerPool {
+    id;
+    name;
+    environment;
+    queueIdentifier;
+    deploymentIdentifier;
+    type = 'flow_run';
+    // Resolved server-side via the configuration chain (pool → env → workspace → zone fallback).
+    // Each field reports the resolved value plus the scope it came from. source === null means
+    // the value is a baked-in default (nothing was found anywhere in the chain).
+    configuration = {
+        enabled: { value: false, source: null },
+        minRunners: { value: 0, source: null },
+        maxRunners: { value: 0, source: null },
+        cpuLimit: { value: null, source: null },
+        memoryLimit: { value: null, source: null },
+        imageId: { value: null, source: null },
+        runnerEndpoint: { value: null, source: null },
+        codeEndpoint: { value: null, source: null },
+        runnerTokenId: { value: null, source: null },
+        codeTokenId: { value: null, source: null },
+    };
+    state = State.Active;
+    static parse(raw) {
+        const queueSpecification = new RunnerPool();
+        queueSpecification.id = raw.id;
+        queueSpecification.name = raw.name;
+        queueSpecification.environment = raw.environment;
+        queueSpecification.queueIdentifier = raw.queue_identifier;
+        queueSpecification.deploymentIdentifier = raw.deployment_identifier;
+        queueSpecification.type = raw.type;
+        // Per-field defensive parsing. Each entry falls back to a default ResolvedValue
+        // if the server didn't send it or sent a malformed shape — keeps the UI alive
+        // when wire contracts drift (e.g. the API auto-strips `_id` so `image_id` arrives
+        // as `image`; we hit that 2026-05-17). Missing/malformed fields are collected and
+        // logged together as a single console.warn so server-side regressions stay visible.
+        const config = raw.configuration ?? {};
+        const missing = [];
+        if (raw.configuration === undefined || raw.configuration === null) {
+            missing.push('(entire configuration object)');
+        }
+        queueSpecification.configuration = {
+            enabled: RunnerPool.parseResolved(config.enabled, false, 'enabled', missing),
+            minRunners: RunnerPool.parseResolved(config.min_runners, 0, 'min_runners', missing),
+            maxRunners: RunnerPool.parseResolved(config.max_runners, 0, 'max_runners', missing),
+            cpuLimit: RunnerPool.parseResolved(config.cpu_limit, null, 'cpu_limit', missing),
+            memoryLimit: RunnerPool.parseResolved(config.memory_limit, null, 'memory_limit', missing),
+            // API strips `_id` suffix from snake_case keys, so `image_id` → `image` on the wire.
+            imageId: RunnerPool.parseResolved(config.image, null, 'image', missing),
+            runnerEndpoint: RunnerPool.parseResolved(config.runner_endpoint, null, 'runner_endpoint', missing),
+            runnerTokenId: RunnerPool.parseResolved(config.runner_token, null, 'runner_token', missing),
+            codeEndpoint: RunnerPool.parseResolved(config.code_endpoint, null, 'code_endpoint', missing),
+            codeTokenId: RunnerPool.parseResolved(config.code_token, null, 'code_token', missing),
+        };
+        if (missing.length > 0) {
+            console.warn('RunnerPool.parse: pool "' + queueSpecification.id + '" has missing or malformed configuration fields', { fields: missing });
+        }
+        queueSpecification.state = State.fromString(raw.state);
+        return queueSpecification;
+    }
+    /**
+     * Coerce a raw wire value into a ResolvedValue<T> envelope. Accepts `{value, source}`
+     * as-is; falls back to `{value: defaultValue, source: null}` when the input is null,
+     * undefined, or missing the envelope shape, and appends the field name to `missing`
+     * so the caller can log a single batched warning. The `value` itself isn't type-
+     * validated — if T is `string | null` and the server sends a number, that's a
+     * server-side bug, not something this layer can fix.
+     */
+    static parseResolved(raw, defaultValue, fieldName, missing) {
+        if (raw !== null && typeof raw === 'object' && 'value' in raw && 'source' in raw) {
+            return raw;
+        }
+        missing.push(fieldName);
+        return { value: defaultValue, source: null };
+    }
+}

package/dist/Model/InfrastructureStatus/QueueStatus.d.ts

@@ -0,0 +1,11 @@
+export declare class QueueStatus {
+    name: string;
+    state: 'nonexisting' | 'running';
+    vhost: string;
+    messages_ready: number;
+    messages_handling: number;
+    message_publish_rate: number;
+    message_handling_rate: number;
+    consumers: number;
+    date: Date;
+}

package/dist/Model/InfrastructureStatus/QueueStatus.js

@@ -0,0 +1,11 @@
+export class QueueStatus {
+    name;
+    state;
+    vhost;
+    messages_ready = 0;
+    messages_handling = 0;
+    message_publish_rate = 0;
+    message_handling_rate = 0;
+    consumers = 0;
+    date;
+}

package/dist/Model/InfrastructureStatus/RunnersStatus.d.ts

@@ -0,0 +1,9 @@
+export declare class RunnersStatus {
+    state: 'nonexisting' | 'running';
+    total: number;
+    running: number;
+    down: number;
+    memory_limit: number | null;
+    cpu_limit: number | null;
+    date: Date;
+}

package/dist/Model/InfrastructureStatus/RunnersStatus.js

@@ -0,0 +1,9 @@
+export class RunnersStatus {
+    state;
+    total;
+    running;
+    down;
+    memory_limit;
+    cpu_limit;
+    date;
+}

package/dist/Model/InfrastructureStatus/StorageStatus.d.ts

@@ -0,0 +1,13 @@
+type StorageTypeStatus = {
+    exists: boolean;
+    used: number;
+    limit: number | null;
+};
+export declare class StorageStatus {
+    persistent: StorageTypeStatus;
+    cache: StorageTypeStatus;
+    vault: StorageTypeStatus;
+    infrastructure: StorageTypeStatus;
+    updated: Date;
+}
+export {};

package/dist/Model/InfrastructureStatus/StorageStatus.js

@@ -0,0 +1,7 @@
+export class StorageStatus {
+    persistent;
+    cache;
+    vault;
+    infrastructure;
+    updated;
+}

package/dist/Model/JsonSerializable.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class JsonSerializable {
+    static stringify(object: {
+        [k: string]: any;
+    }): string;
+    abstract jsonSerialize(): any;
+}

package/dist/Model/JsonSerializable.js

@@ -0,0 +1,12 @@
+export class JsonSerializable {
+    static stringify(object) {
+        const replacer = (key, value) => {
+            // Filtering out properties
+            if (value instanceof JsonSerializable && 'jsonSerialize' in value) {
+                return value.jsonSerialize();
+            }
+            return value;
+        };
+        return JSON.stringify(object, replacer);
+    }
+}

package/dist/Model/Log/Log.d.ts

@@ -0,0 +1,17 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+import { LogLevel } from './LogLevel.js';
+import { LogStatus } from './LogStatus.js';
+import { LogStreamId } from './LogStreamId.js';
+export declare class Log {
+    id: string;
+    readonly logStream: LogStreamId;
+    readonly date: Date;
+    readonly level: LogLevel;
+    readonly message: string;
+    context: object;
+    status: LogStatus;
+    tags: DataValueCollection;
+    _version: string;
+    constructor(logStream: LogStreamId, message: string, level: LogLevel, date: Date);
+    static parse(rawLog: any): Log;
+}

package/dist/Model/Log/Log.js

@@ -0,0 +1,37 @@
+import { Utils } from '../../Utils.js';
+import { DataValueCollection } from '../DataValueCollection.js';
+import { LogLevel } from './LogLevel.js';
+import { LogStatus } from './LogStatus.js';
+import { LogStreamId } from './LogStreamId.js';
+export class Log {
+    id;
+    logStream;
+    date;
+    level;
+    message;
+    context;
+    status = LogStatus.Normal;
+    tags;
+    _version;
+    constructor(logStream, message, level, date) {
+        this.logStream = logStream;
+        this.message = message;
+        this.level = level;
+        this.date = date;
+        this.tags = new DataValueCollection();
+    }
+    static parse(rawLog) {
+        const date = Utils.parseRawDate(rawLog.date);
+        const level = LogLevel.fromString(rawLog.level);
+        const logStream = new LogStreamId(rawLog.log_stream);
+        const log = new Log(logStream, rawLog.message, level, date);
+        log.id = rawLog.id;
+        log.context = rawLog.context;
+        if (rawLog.status !== null && rawLog.status !== undefined && rawLog.status !== '') {
+            log.status = LogStatus.fromString(rawLog.status);
+        }
+        log.tags = DataValueCollection.fromObject(rawLog.tags);
+        log._version = rawLog._version;
+        return log;
+    }
+}

package/dist/Model/Log/LogLevel.d.ts

@@ -0,0 +1,15 @@
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Notice = "notice",
+    Warning = "warning",
+    Error = "error",
+    Critical = "critical",
+    Alert = "alert",
+    Emergency = "emergency"
+}
+export declare namespace LogLevel {
+    const compare: (logLevelA: LogLevel, logLevelB: LogLevel) => number;
+    const toNumeric: (logLevel: LogLevel) => number;
+    const fromString: (input: string) => LogLevel;
+}

package/dist/Model/Log/LogLevel.js

@@ -0,0 +1,54 @@
+import { Utils } from '../../Utils.js';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Notice"] = "notice";
+    LogLevel["Warning"] = "warning";
+    LogLevel["Error"] = "error";
+    LogLevel["Critical"] = "critical";
+    LogLevel["Alert"] = "alert";
+    LogLevel["Emergency"] = "emergency";
+})(LogLevel || (LogLevel = {}));
+(function (LogLevel) {
+    LogLevel.compare = (logLevelA, logLevelB) => {
+        const logLevelANumeric = LogLevel.toNumeric(logLevelA);
+        const logLevelBNumeric = LogLevel.toNumeric(logLevelB);
+        if (logLevelANumeric > logLevelBNumeric) {
+            return 1;
+        }
+        if (logLevelANumeric < logLevelBNumeric) {
+            return -1;
+        }
+        return 0;
+    };
+    LogLevel.toNumeric = (logLevel) => {
+        switch (logLevel) {
+            case LogLevel.Debug:
+                return 100;
+            case LogLevel.Info:
+                return 200;
+            case LogLevel.Notice:
+                return 250;
+            case LogLevel.Warning:
+                return 300;
+            case LogLevel.Error:
+                return 400;
+            case LogLevel.Critical:
+                return 500;
+            case LogLevel.Alert:
+                return 550;
+            case LogLevel.Emergency:
+                return 600;
+            default:
+                throw new Error('Unknown log level "' + logLevel + '"');
+        }
+    };
+    LogLevel.fromString = (input) => {
+        const result = Utils.parseEnum(input, LogLevel);
+        if (result === null) {
+            throw new Error('Unable to parse LogLevel from string: Unknown LogLevel "' + input + '"');
+        }
+        return result;
+    };
+})(LogLevel || (LogLevel = {}));

package/dist/Model/Log/LogQuery.d.ts

@@ -0,0 +1,26 @@
+import { LogLevel } from './LogLevel.js';
+import { LogStreamId } from './LogStreamId.js';
+import { DataValueValue } from '../DataValue.js';
+export declare class LogQuery {
+    readonly logStreamId: LogStreamId;
+    /** @deprecated use filters property instead **/
+    message: string | null;
+    hidden: boolean | null;
+    logLevels: LogLevel[] | null;
+    tags: Array<{
+        key: string;
+        values: DataValueValue[];
+    }> | null;
+    filters: {
+        field: 'message' | 'context';
+        value: string;
+        method: 'contains';
+    }[];
+    limit: number | null;
+    startingAfterId: string | null;
+    sort: Array<{
+        field: string;
+        direction: number;
+    }>;
+    constructor(logStreamId: LogStreamId);
+}

package/dist/Model/Log/LogQuery.js

@@ -0,0 +1,15 @@
+export class LogQuery {
+    logStreamId;
+    /** @deprecated use filters property instead **/
+    message = null;
+    hidden = null;
+    logLevels = null;
+    tags = null;
+    filters = [];
+    limit = null;
+    startingAfterId = null;
+    sort;
+    constructor(logStreamId) {
+        this.logStreamId = logStreamId;
+    }
+}

package/dist/Model/Log/LogStatus.d.ts

@@ -0,0 +1,8 @@
+export declare enum LogStatus {
+    Normal = "normal",
+    Ignored = "ignored",
+    Resolved = "resolved"
+}
+export declare namespace LogStatus {
+    const fromString: (input: string) => LogStatus;
+}

package/dist/Model/Log/LogStatus.js

@@ -0,0 +1,16 @@
+import { Utils } from '../../Utils.js';
+export var LogStatus;
+(function (LogStatus) {
+    LogStatus["Normal"] = "normal";
+    LogStatus["Ignored"] = "ignored";
+    LogStatus["Resolved"] = "resolved";
+})(LogStatus || (LogStatus = {}));
+(function (LogStatus) {
+    LogStatus.fromString = (input) => {
+        const result = Utils.parseEnum(input, LogStatus);
+        if (result === null) {
+            throw new Error('Unable to parse LogStatus from string: Unknown LogStatus "' + input + '"');
+        }
+        return result;
+    };
+})(LogStatus || (LogStatus = {}));

package/dist/Model/Log/LogStream.d.ts

@@ -0,0 +1,6 @@
+import { LogStreamId } from './LogStreamId.js';
+export declare class LogStream {
+    id: LogStreamId;
+    name: string;
+    constructor(id: LogStreamId, name: string);
+}

package/dist/Model/Log/LogStream.js

@@ -0,0 +1,8 @@
+export class LogStream {
+    id;
+    name;
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+}

package/dist/Model/Log/LogStreamId.d.ts

@@ -0,0 +1,5 @@
+import { EntityId } from '../EntityId.js';
+export declare class LogStreamId extends EntityId {
+    protected readonly TYPE: string;
+    jsonSerialize(): string;
+}

package/dist/Model/Log/LogStreamId.js

@@ -0,0 +1,7 @@
+import { EntityId } from '../EntityId.js';
+export class LogStreamId extends EntityId {
+    TYPE = 'logStreamId';
+    jsonSerialize() {
+        return this.id;
+    }
+}

package/dist/Model/Log/LogStreamInformation.d.ts

@@ -0,0 +1,18 @@
+import { LogLevel } from './LogLevel.js';
+import { DataValueValue } from '../DataValue.js';
+import { LogStreamId } from './LogStreamId.js';
+export declare class LogStreamInformation {
+    logStreamId: LogStreamId;
+    logLevels: {
+        logLevel: LogLevel;
+        count: number;
+    }[];
+    tags: {
+        tag: string;
+        values: {
+            value: DataValueValue;
+            count: number;
+        }[];
+    }[];
+    static parse(raw: any): LogStreamInformation;
+}

package/dist/Model/Log/LogStreamInformation.js

@@ -0,0 +1,58 @@
+import { LogLevel } from './LogLevel.js';
+import { LogStreamId } from './LogStreamId.js';
+export class LogStreamInformation {
+    logStreamId;
+    logLevels;
+    tags;
+    static parse(raw) {
+        const rawData = raw;
+        if (rawData === null || rawData === undefined) {
+            throw new Error('Invalid response');
+        }
+        const result = new LogStreamInformation();
+        result.logStreamId = new LogStreamId(rawData.log_stream);
+        /**
+         * LogLevel
+         */
+        result.logLevels = [];
+        for (const logLevel of rawData.log_levels) {
+            result.logLevels.push({ logLevel: LogLevel.fromString(logLevel.log_level), count: logLevel.count });
+        }
+        /**
+         * Tags
+         */
+        result.tags = [];
+        for (const tag of rawData.tags) {
+            const values = [];
+            for (const tagValue of tag.values) {
+                values.push({ value: tagValue.value, count: tagValue.count });
+            }
+            result.tags.push({ tag: tag.tag, values: values });
+        }
+        // Object.keys(rawData.level_count).forEach((logLevelKey: string, index) => {
+        //
+        //     const logLevel: LogLevel = LogLevel.fromString(logLevelKey);
+        //
+        //     const parsedCount: number | null = parseInt(rawData.level_count[logLevelKey], undefined);
+        //     if (parsedCount !== null) {
+        //         logLevels.set(logLevel, parsedCount);
+        //     } else {
+        //         console.error('Unserialize log level count: Unable to parse log level count', rawData.level_count[logLevelKey]);
+        //     }
+        //
+        // });
+        // const tags: Map<string, DataValueValue[]> = new Map<string, DataValueValue[]>();
+        // if (rawData.tags !== null && rawData.tags !== undefined) {
+        //
+        //     Object.keys(rawData.tags).forEach((tagKey: string, index) => {
+        //
+        //         const values: DataValueValue[] = rawData.tags[tagKey];
+        //
+        //         tags.set(tagKey, values);
+        //
+        //     });
+        // }
+        // throw new Error('Need update!');
+        return result;
+    }
+}

package/dist/Model/Messaging/Channel/Channel.d.ts

@@ -0,0 +1,16 @@
+import { State } from '../../State.js';
+import { StateAware } from '../../StateAware.js';
+import { MetaDataAware } from '../../../Core/MetaDataAware.js';
+import { ChannelType } from './ChannelType.js';
+export declare class Channel extends MetaDataAware implements StateAware {
+    id: string;
+    ownerId: string;
+    type: ChannelType;
+    data: any;
+    state: State;
+    workspaces: string[];
+    isPrivate: boolean;
+    singleUse: boolean;
+    constructor(id: string, ownerId: string, name: string, type: ChannelType, data: any);
+    static parse(rawChannel: Record<string, unknown>): Channel;
+}

package/dist/Model/Messaging/Channel/Channel.js

@@ -0,0 +1,31 @@
+import { State } from '../../State.js';
+import { Utils } from '../../../Utils.js';
+import { MetaDataAware } from '../../../Core/MetaDataAware.js';
+import { ChannelType } from './ChannelType.js';
+export class Channel extends MetaDataAware {
+    id;
+    ownerId;
+    type;
+    data;
+    state = State.Active;
+    workspaces = [];
+    isPrivate = false;
+    singleUse = false;
+    constructor(id, ownerId, name, type, data) {
+        super();
+        this.id = id;
+        this.ownerId = ownerId;
+        this.name = name;
+        this.type = type;
+        this.data = data;
+    }
+    static parse(rawChannel) {
+        const type = ChannelType.fromString(rawChannel.type);
+        const channel = new Channel(rawChannel.id, rawChannel.owner, rawChannel.name, type, rawChannel.data);
+        channel.state = State.fromString(rawChannel.state);
+        channel.isPrivate = Utils.isTrue(rawChannel.is_private);
+        channel.singleUse = Utils.isTrue(rawChannel.single_use);
+        channel.workspaces = rawChannel.workspaces;
+        return channel;
+    }
+}

package/dist/Model/Messaging/Channel/ChannelData.d.ts

@@ -0,0 +1,6 @@
+import { ChannelType } from './ChannelType.js';
+export declare abstract class ChannelData {
+    type: ChannelType;
+    constructor(type: ChannelType);
+    toString(): string;
+}

package/dist/Model/Messaging/Channel/ChannelData.js

@@ -0,0 +1,9 @@
+export class ChannelData {
+    type;
+    constructor(type) {
+        this.type = type;
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+}

package/dist/Model/Messaging/Channel/ChannelType.d.ts

@@ -0,0 +1,10 @@
+export declare enum ChannelType {
+    Email = "email",
+    Push = "push",
+    Slack = "slack",
+    SMS = "sms",
+    Webhook = "webhook"
+}
+export declare namespace ChannelType {
+    const fromString: (input: string) => ChannelType;
+}

package/dist/Model/Messaging/Channel/ChannelType.js

@@ -0,0 +1,18 @@
+import { Utils } from '../../../Utils.js';
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType["Email"] = "email";
+    ChannelType["Push"] = "push";
+    ChannelType["Slack"] = "slack";
+    ChannelType["SMS"] = "sms";
+    ChannelType["Webhook"] = "webhook";
+})(ChannelType || (ChannelType = {}));
+(function (ChannelType) {
+    ChannelType.fromString = (input) => {
+        const result = Utils.parseEnum(input, ChannelType);
+        if (result === null) {
+            throw new Error('Unable to parse ChannelType from string: Unknown ChannelType "' + input + '"');
+        }
+        return result;
+    };
+})(ChannelType || (ChannelType = {}));

package/dist/Model/Messaging/Channel/EmailChannelData.d.ts

@@ -0,0 +1,5 @@
+import { ChannelData } from './ChannelData.js';
+export declare class EmailChannelData extends ChannelData {
+    email: string;
+    constructor(email: string);
+}

package/dist/Model/Messaging/Channel/EmailChannelData.js

@@ -0,0 +1,9 @@
+import { ChannelData } from './ChannelData.js';
+import { ChannelType } from './ChannelType.js';
+export class EmailChannelData extends ChannelData {
+    email;
+    constructor(email) {
+        super(ChannelType.Email);
+        this.email = email;
+    }
+}