@attlaz/client 1.77.1

package/dist/Model/ApiRecord.js

@@ -0,0 +1 @@
+export {};

package/dist/Model/Collections/Collection.d.ts

@@ -0,0 +1,13 @@
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Collection {
+    id: string;
+    project: string;
+    name: string;
+    properties: {
+        id: string;
+        name: string;
+        type: string;
+        options: string[];
+    }[];
+    static parse(raw: ApiRecord): Collection;
+}

package/dist/Model/Collections/Collection.js

@@ -0,0 +1,15 @@
+export class Collection {
+    id;
+    project;
+    name;
+    properties;
+    // records: CollectionRecord[];
+    static parse(raw) {
+        const collection = new Collection();
+        collection.id = raw.id;
+        collection.project = raw.project;
+        collection.name = raw.name;
+        collection.properties = raw.properties;
+        return collection;
+    }
+}

package/dist/Model/Collections/CollectionRecord.d.ts

@@ -0,0 +1,6 @@
+export declare class CollectionRecord {
+    id: string;
+    collection: string;
+    properties: Record<string, unknown>;
+    static parse(raw: Record<string, unknown>): CollectionRecord;
+}

package/dist/Model/Collections/CollectionRecord.js

@@ -0,0 +1,12 @@
+export class CollectionRecord {
+    id;
+    collection;
+    properties;
+    static parse(raw) {
+        const record = new CollectionRecord();
+        record.id = raw.id;
+        record.collection = raw.collection;
+        record.properties = raw.properties;
+        return record;
+    }
+}

package/dist/Model/Command/CommandExecutionFilter.d.ts

@@ -0,0 +1,6 @@
+import { CommandExecutionStatus } from './CommandExecutionStatus.js';
+export interface CommandExecutionFilter {
+    status?: CommandExecutionStatus[];
+    type?: string[];
+    requestedBy?: string[];
+}

package/dist/Model/Command/CommandExecutionFilter.js

@@ -0,0 +1 @@
+export {};

package/dist/Model/Command/CommandExecutionHistory.d.ts

@@ -0,0 +1,15 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+import { CommandExecutionStatus } from './CommandExecutionStatus.js';
+export declare class CommandExecutionHistory {
+    id: string;
+    commandType: string;
+    commandTime: Date;
+    commandData: DataValueCollection;
+    commandVersion: string;
+    requestedBy: string;
+    executionStarted: Date | null;
+    executionFinished: Date | null;
+    executionStatus: CommandExecutionStatus;
+    executionError: string | null;
+    executionResult: string | null;
+}

package/dist/Model/Command/CommandExecutionHistory.js

@@ -0,0 +1,15 @@
+export class CommandExecutionHistory {
+    id;
+    commandType;
+    commandTime;
+    commandData;
+    commandVersion;
+    // The user that requested the command (the platform system user for cron/event/maintenance commands).
+    requestedBy;
+    executionStarted;
+    executionFinished;
+    executionStatus;
+    executionError;
+    // Structured result payload as a JSON string (e.g. '{"removedCount": 1234}'); shape depends on the command type.
+    executionResult;
+}

package/dist/Model/Command/CommandExecutionStatus.d.ts

@@ -0,0 +1,9 @@
+export declare enum CommandExecutionStatus {
+    Pending = "pending",
+    Running = "running",
+    Completed = "completed",
+    Failed = "failed"
+}
+export declare namespace CommandExecutionStatus {
+    const fromString: (input: string) => CommandExecutionStatus;
+}

package/dist/Model/Command/CommandExecutionStatus.js

@@ -0,0 +1,20 @@
+export var CommandExecutionStatus;
+(function (CommandExecutionStatus) {
+    CommandExecutionStatus["Pending"] = "pending";
+    CommandExecutionStatus["Running"] = "running";
+    CommandExecutionStatus["Completed"] = "completed";
+    CommandExecutionStatus["Failed"] = "failed";
+})(CommandExecutionStatus || (CommandExecutionStatus = {}));
+(function (CommandExecutionStatus) {
+    CommandExecutionStatus.fromString = (input) => {
+        switch (input) {
+            case CommandExecutionStatus.Pending:
+            case CommandExecutionStatus.Running:
+            case CommandExecutionStatus.Completed:
+            case CommandExecutionStatus.Failed:
+                return input;
+            default:
+                throw new Error('Unknown CommandExecutionStatus "' + input + '"');
+        }
+    };
+})(CommandExecutionStatus || (CommandExecutionStatus = {}));

package/dist/Model/Config.d.ts

@@ -0,0 +1,17 @@
+import { State } from './State.js';
+/**
+ * @deprecated
+ */
+export declare class Config {
+    id: number;
+    projectId: string;
+    projectEnvironmentId: string;
+    flowId: string;
+    scope: string;
+    key: string;
+    value: string;
+    inheritable: boolean;
+    sensitive: boolean;
+    state: State;
+    static parse(rawConfig: Record<string, any>): Config;
+}

package/dist/Model/Config.js

@@ -0,0 +1,31 @@
+import { Utils } from '../Utils.js';
+import { State } from './State.js';
+/**
+ * @deprecated
+ */
+export class Config {
+    id;
+    projectId;
+    projectEnvironmentId;
+    flowId;
+    scope;
+    key;
+    value;
+    inheritable = true;
+    sensitive = true;
+    state = State.Active;
+    static parse(rawConfig) {
+        const config = new Config();
+        config.id = rawConfig.id;
+        config.projectId = rawConfig.project;
+        config.projectEnvironmentId = rawConfig.project_environment;
+        config.flowId = rawConfig.flow;
+        config.scope = rawConfig.scope;
+        config.key = rawConfig.key;
+        config.value = rawConfig.value;
+        config.inheritable = Utils.isTrue(rawConfig.inheritable);
+        config.sensitive = Utils.isTrue(rawConfig.sensitive);
+        config.state = State.fromString(rawConfig.state);
+        return config;
+    }
+}

package/dist/Model/Configuration/Configuration.d.ts

@@ -0,0 +1,10 @@
+import { State } from '../State.js';
+import { DataValueValue } from '../DataValue.js';
+export declare class Configuration {
+    id: string;
+    path: string;
+    value: DataValueValue;
+    state: State;
+    scope: string;
+    static parse(rawConfig: Record<string, unknown>): Configuration;
+}

package/dist/Model/Configuration/Configuration.js

@@ -0,0 +1,17 @@
+import { State } from '../State.js';
+export class Configuration {
+    id;
+    path;
+    value;
+    state;
+    scope;
+    static parse(rawConfig) {
+        const config = new Configuration();
+        config.id = rawConfig.id;
+        config.path = rawConfig.path;
+        config.value = rawConfig.value;
+        config.state = State.fromString(rawConfig.state);
+        config.scope = rawConfig.scope;
+        return config;
+    }
+}

package/dist/Model/DataValue.d.ts

@@ -0,0 +1,6 @@
+export type DataValueValue = string | number | boolean;
+export declare class DataValue {
+    key: string;
+    value: DataValueValue;
+    constructor(key: string, value: DataValueValue);
+}

package/dist/Model/DataValue.js

@@ -0,0 +1,8 @@
+export class DataValue {
+    key;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}

package/dist/Model/DataValueCollection.d.ts

@@ -0,0 +1,17 @@
+import { DataValue, DataValueValue } from './DataValue.js';
+import { JsonSerializable } from './JsonSerializable.js';
+export declare class DataValueCollection extends JsonSerializable implements Iterable<DataValue> {
+    private _values;
+    get length(): number;
+    static fromObject(rawValues: {
+        key: string;
+        value: DataValueValue;
+    }[] | null): DataValueCollection;
+    set(key: string, value: DataValueValue): void;
+    has(key: string): boolean;
+    get(key: string): DataValueValue | null;
+    unset(key: string): void;
+    serialize(): string | null;
+    [Symbol.iterator](): Iterator<DataValue>;
+    jsonSerialize(): any;
+}

package/dist/Model/DataValueCollection.js

@@ -0,0 +1,61 @@
+import { Utils } from '../Utils.js';
+import { DataValue } from './DataValue.js';
+import { JsonSerializable } from './JsonSerializable.js';
+export class DataValueCollection extends JsonSerializable {
+    _values = [];
+    get length() {
+        return this._values.length;
+    }
+    static fromObject(rawValues) {
+        if (rawValues === null || rawValues === undefined) {
+            return new DataValueCollection();
+        }
+        if (!Utils.isIterable(rawValues)) {
+            throw new Error('Unable to parse data value collection: values are not iterable: ' + JSON.stringify(rawValues));
+        }
+        const result = new DataValueCollection();
+        for (const rawValue of rawValues) {
+            // TODO: validate rawTag
+            result.set(rawValue.key, rawValue.value);
+        }
+        return result;
+    }
+    set(key, value) {
+        const existingIndex = this._values.findIndex((tag) => tag.key === key);
+        if (existingIndex !== -1) {
+            this._values.splice(existingIndex);
+        }
+        this._values.push(new DataValue(key, value));
+    }
+    has(key) {
+        for (const tag of this._values) {
+            if (tag.key === key) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get(key) {
+        for (const tag of this._values) {
+            if (tag.key === key) {
+                return tag.value;
+            }
+        }
+        return null;
+    }
+    unset(key) {
+        this._values = this._values.filter((tag) => tag.key !== key);
+    }
+    serialize() {
+        if (this._values.length === 0) {
+            return null;
+        }
+        return JSON.stringify(this._values);
+    }
+    [Symbol.iterator]() {
+        return this._values.values();
+    }
+    jsonSerialize() {
+        return this._values;
+    }
+}

package/dist/Model/Deployment/CodeSource.d.ts

@@ -0,0 +1,24 @@
+import { MetaDataWithIconAware } from '../../Core/MetaDataWithIconAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class CodeSource extends MetaDataWithIconAware implements StateAware {
+    id: string;
+    codeSourceAccountId: string;
+    repository: {
+        key: string;
+        name: string;
+        url: string;
+    };
+    branch: string;
+    platformId: string;
+    buildStrategyId: string;
+    runStrategyId: string;
+    state: State;
+    usage: {
+        flows: number;
+        environments: number;
+    } | null;
+    deployCount: number | null;
+    static parse(rawCodeSource: ApiRecord): CodeSource;
+}

package/dist/Model/Deployment/CodeSource.js

@@ -0,0 +1,32 @@
+import { MetaDataWithIconAware } from '../../Core/MetaDataWithIconAware.js';
+import { State } from '../State.js';
+export class CodeSource extends MetaDataWithIconAware {
+    id;
+    codeSourceAccountId;
+    repository;
+    branch;
+    platformId;
+    buildStrategyId;
+    runStrategyId;
+    state = State.Active;
+    usage = null;
+    deployCount = null;
+    static parse(rawCodeSource) {
+        const codeSource = MetaDataWithIconAware.parseMetaData(new CodeSource(), rawCodeSource);
+        codeSource.id = rawCodeSource.id;
+        codeSource.codeSourceAccountId = rawCodeSource.code_source_account;
+        codeSource.repository = rawCodeSource.repository;
+        codeSource.branch = rawCodeSource.branch;
+        codeSource.platformId = rawCodeSource.platform;
+        codeSource.buildStrategyId = rawCodeSource.build_strategy;
+        codeSource.runStrategyId = rawCodeSource.run_strategy;
+        codeSource.state = State.fromString(rawCodeSource.state);
+        if (Object.prototype.hasOwnProperty.call(rawCodeSource, 'usage')) {
+            codeSource.usage = rawCodeSource.usage;
+        }
+        if (Object.prototype.hasOwnProperty.call(rawCodeSource, 'deploys')) {
+            codeSource.deployCount = rawCodeSource.deploys;
+        }
+        return codeSource;
+    }
+}

package/dist/Model/Deployment/CodeSourceAccount.d.ts

@@ -0,0 +1,13 @@
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class CodeSourceAccount extends MetaDataAware implements StateAware {
+    id: string;
+    userId: string;
+    workspaceId: string;
+    type: string;
+    providerToken: string | null;
+    state: State;
+    static parse(rawSourcesAccount: ApiRecord): CodeSourceAccount;
+}

package/dist/Model/Deployment/CodeSourceAccount.js

@@ -0,0 +1,25 @@
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { State } from '../State.js';
+export class CodeSourceAccount extends MetaDataAware {
+    id;
+    userId;
+    workspaceId;
+    type;
+    providerToken;
+    // public access_token: string;
+    // public refresh_token: string;
+    // public scopes: string;
+    state;
+    static parse(rawSourcesAccount) {
+        const sourcesAccount = MetaDataAware.parseMetaData(new CodeSourceAccount(), rawSourcesAccount);
+        sourcesAccount.userId = rawSourcesAccount.user;
+        sourcesAccount.workspaceId = rawSourcesAccount.workspace;
+        sourcesAccount.type = rawSourcesAccount.type;
+        sourcesAccount.providerToken = rawSourcesAccount.provider_token;
+        // sourcesAccount.access_token = rawSourcesAccount.access_token;
+        // sourcesAccount.refresh_token = rawSourcesAccount.refresh_token;
+        // sourcesAccount.scopes = rawSourcesAccount.scopes;
+        sourcesAccount.state = State.fromString(rawSourcesAccount.state);
+        return sourcesAccount;
+    }
+}

package/dist/Model/Deployment/CodeSourceBuildStrategy.d.ts

@@ -0,0 +1,10 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class CodeSourceBuildStrategy implements StateAware {
+    id: string;
+    name: string;
+    description: string;
+    languageId: string;
+    state: State;
+    static parse(raw: any): CodeSourceBuildStrategy;
+}

package/dist/Model/Deployment/CodeSourceBuildStrategy.js

@@ -0,0 +1,17 @@
+import { State } from '../State.js';
+export class CodeSourceBuildStrategy {
+    id;
+    name;
+    description;
+    languageId;
+    state = State.Active;
+    static parse(raw) {
+        const codeDeployStrategy = new CodeSourceBuildStrategy();
+        codeDeployStrategy.id = raw.id;
+        codeDeployStrategy.name = raw.name;
+        codeDeployStrategy.description = raw.description;
+        codeDeployStrategy.languageId = raw.language;
+        codeDeployStrategy.state = State.fromString(raw.state);
+        return codeDeployStrategy;
+    }
+}

package/dist/Model/Deployment/CodeSourceRunStrategy.d.ts

@@ -0,0 +1,10 @@
+import { StateAware } from '../StateAware.js';
+import { State } from '../State.js';
+export declare class CodeSourceRunStrategy implements StateAware {
+    id: string;
+    name: string;
+    description: string;
+    languageId: string;
+    state: State;
+    static parse(raw: any): CodeSourceRunStrategy;
+}

package/dist/Model/Deployment/CodeSourceRunStrategy.js

@@ -0,0 +1,17 @@
+import { State } from '../State.js';
+export class CodeSourceRunStrategy {
+    id;
+    name;
+    description;
+    languageId;
+    state = State.Active;
+    static parse(raw) {
+        const runStrategy = new CodeSourceRunStrategy();
+        runStrategy.id = raw.id;
+        runStrategy.name = raw.name;
+        runStrategy.description = raw.description;
+        runStrategy.languageId = raw.language;
+        runStrategy.state = State.fromString(raw.state);
+        return runStrategy;
+    }
+}

package/dist/Model/Deployment/SourcesAccountRepository.d.ts

@@ -0,0 +1,7 @@
+export declare class SourcesAccountRepository {
+    key: string;
+    name: string;
+    url: string;
+    description: string;
+    static parse(rawSourcesAccountRepository: any): SourcesAccountRepository;
+}

package/dist/Model/Deployment/SourcesAccountRepository.js

@@ -0,0 +1,14 @@
+export class SourcesAccountRepository {
+    key;
+    name;
+    url;
+    description;
+    static parse(rawSourcesAccountRepository) {
+        const sourcesAccountRepository = new SourcesAccountRepository();
+        sourcesAccountRepository.key = rawSourcesAccountRepository.key;
+        sourcesAccountRepository.name = rawSourcesAccountRepository.name;
+        sourcesAccountRepository.url = rawSourcesAccountRepository.url;
+        sourcesAccountRepository.description = rawSourcesAccountRepository.description;
+        return sourcesAccountRepository;
+    }
+}

package/dist/Model/Deployment/SourcesAccountRepositoryBranch.d.ts

@@ -0,0 +1,4 @@
+export declare class SourcesAccountRepositoryBranch {
+    key: string;
+    static parse(raw: any): SourcesAccountRepositoryBranch;
+}

package/dist/Model/Deployment/SourcesAccountRepositoryBranch.js

@@ -0,0 +1,8 @@
+export class SourcesAccountRepositoryBranch {
+    key;
+    static parse(raw) {
+        const sourcesAccountRepositoryBranch = new SourcesAccountRepositoryBranch();
+        sourcesAccountRepositoryBranch.key = raw.key;
+        return sourcesAccountRepositoryBranch;
+    }
+}

package/dist/Model/EntityId.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class EntityId {
+    protected readonly id: string;
+    protected readonly abstract TYPE: string;
+    constructor(id: string);
+    getIdType(): string;
+    toString(): string;
+    jsonSerialize(): any;
+    isEqual<T extends this>(entityId: T): boolean;
+}

package/dist/Model/EntityId.js

@@ -0,0 +1,27 @@
+export class EntityId {
+    id;
+    constructor(id) {
+        this.id = id;
+        if (id === null || id === undefined || (id + '').length < 1) {
+            throw new Error('Invalid entity id (' + this.constructor.name + ')');
+        }
+        if ((id + '').length !== 27) {
+            // console.error('Id `' + id + '` does not seem a valid KSUID (type `' + this.getIdType() + '`)');
+        }
+    }
+    getIdType() {
+        return this.TYPE;
+    }
+    toString() {
+        return this.id;
+    }
+    jsonSerialize() {
+        return this.toString();
+    }
+    isEqual(entityId) {
+        if (this.getIdType() !== entityId.getIdType()) {
+            throw new Error('Types are not the same');
+        }
+        return this.getIdType() !== '' && entityId.getIdType() !== '' && this.getIdType() === entityId.getIdType() && this.toString() === entityId.toString();
+    }
+}

package/dist/Model/EntityType.d.ts

@@ -0,0 +1,25 @@
+export declare enum EntityType {
+    Organisation = "organisation",
+    Workspace = "workspace",
+    Project = "project",
+    ProjectEnvironment = "project-environment",
+    Flow = "flow",
+    FlowRun = "flow-run",
+    User = "user",
+    UserAuthProvider = "user-auth-provider",
+    WorkspaceMember = "workspace-member",
+    Adapter = "adapter",
+    AdapterConnection = "adapter-connection",
+    Trigger = "trigger",
+    Channel = "channel",
+    ChannelSubscriber = "channel-subscriber",
+    CodeSourceAccount = "code-source-account",
+    CodeSource = "code-source",
+    CodeSourceDeploy = "code-source-deploy",
+    StorageBucket = "storage-bucket",
+    LogStream = "log-stream",
+    RunnerPool = "runner-pool"
+}
+export declare namespace EntityType {
+    const fromString: (input: string) => EntityType;
+}

package/dist/Model/EntityType.js

@@ -0,0 +1,33 @@
+import { Utils } from '../Utils.js';
+export var EntityType;
+(function (EntityType) {
+    EntityType["Organisation"] = "organisation";
+    EntityType["Workspace"] = "workspace";
+    EntityType["Project"] = "project";
+    EntityType["ProjectEnvironment"] = "project-environment";
+    EntityType["Flow"] = "flow";
+    EntityType["FlowRun"] = "flow-run";
+    EntityType["User"] = "user";
+    EntityType["UserAuthProvider"] = "user-auth-provider";
+    EntityType["WorkspaceMember"] = "workspace-member";
+    EntityType["Adapter"] = "adapter";
+    EntityType["AdapterConnection"] = "adapter-connection";
+    EntityType["Trigger"] = "trigger";
+    EntityType["Channel"] = "channel";
+    EntityType["ChannelSubscriber"] = "channel-subscriber";
+    EntityType["CodeSourceAccount"] = "code-source-account";
+    EntityType["CodeSource"] = "code-source";
+    EntityType["CodeSourceDeploy"] = "code-source-deploy";
+    EntityType["StorageBucket"] = "storage-bucket";
+    EntityType["LogStream"] = "log-stream";
+    EntityType["RunnerPool"] = "runner-pool";
+})(EntityType || (EntityType = {}));
+(function (EntityType) {
+    EntityType.fromString = (input) => {
+        const result = Utils.parseEnum(input, EntityType);
+        if (result === null) {
+            throw new Error('Unable to parse EntityType from string: Unknown EntityType "' + input + '"');
+        }
+        return result;
+    };
+})(EntityType || (EntityType = {}));

package/dist/Model/Error/ApiError.d.ts

@@ -0,0 +1,14 @@
+import { ClientError } from '../../Http/ClientError.js';
+/**
+ * Domain-level error produced at the API/Endpoint boundary. Extends ClientError so a single
+ * `instanceof ClientError` catches both transport failures (ClientError) and API errors
+ * (ApiError), while adding the server's structured error fields (type/code/param).
+ *
+ * httpStatus, message and response are inherited from ClientError.
+ */
+export declare class ApiError extends ClientError {
+    type: string;
+    code: string;
+    param?: string | undefined;
+    constructor(message: string, httpErrorCode?: number | null);
+}

package/dist/Model/Error/ApiError.js

@@ -0,0 +1,16 @@
+import { ClientError } from '../../Http/ClientError.js';
+/**
+ * Domain-level error produced at the API/Endpoint boundary. Extends ClientError so a single
+ * `instanceof ClientError` catches both transport failures (ClientError) and API errors
+ * (ApiError), while adding the server's structured error fields (type/code/param).
+ *
+ * httpStatus, message and response are inherited from ClientError.
+ */
+export class ApiError extends ClientError {
+    type;
+    code;
+    param = undefined;
+    constructor(message, httpErrorCode = null) {
+        super(message, httpErrorCode);
+    }
+}

package/dist/Model/Event/EventType.d.ts

@@ -0,0 +1,17 @@
+export declare enum EventType {
+    /** @deprecated * */
+    TaskExecutionRequested = "TaskExecutionRequested",
+    /** @deprecated * */
+    TaskExecutionStarted = "TaskExecutionStarted",
+    /** @deprecated * */
+    TaskExecutionFailed = "TaskExecutionFailed",
+    /** @deprecated * */
+    TaskExecutionComplete = "TaskExecutionComplete",
+    /** @deprecated * */
+    TaskExecutionRetry = "TaskExecutionRetry",
+    FlowRunRequested = "FlowRunRequested",
+    FlowRunStarted = "FlowRunStarted",
+    FlowRunFailed = "FlowRunFailed",
+    FlowRunComplete = "FlowRunComplete",
+    FlowRunRetry = "FlowRunRetry"
+}