attlaz-client 1.18.8 → 1.18.10

package/dist/Client.d.ts

@@ -34,7 +34,7 @@ export declare class Client {
     private readonly endpoints;
     private httpClient;
     private readonly Store;
-    private apiEndpoint;
+    private readonly apiEndpoint;
     private parseConfig;
     constructor(token?: string | null, config?: {
         apiEndpoint: string | undefined;

package/dist/Http/ClientError.d.ts

@@ -3,7 +3,6 @@ export declare class ClientError extends Error {
     httpStatus: number | null;
     type: string;
     code: string;
-    message: string;
     param?: string | undefined;
     stack?: string;
     constructor(code: string, httpErrorCode?: number | null);

package/dist/Http/ClientError.js

@@ -4,7 +4,7 @@ export class ClientError extends Error {
     httpStatus = null;
     type;
     code;
-    message;
+    // public message: string;
     param = undefined;
     stack;
     constructor(code, httpErrorCode = null) {
@@ -25,22 +25,36 @@ export class ClientError extends Error {
                 clientError.code = error.code;
             }
             if (error.response === undefined) {
-                console.error('Unable to parse AxiosError response', { error });
-            }
-            else {
-                // console.debug('Parse response', {error: error, data: error.response.data});
-                const errorData = error.response.data;
-                if (errorData.type !== undefined) {
-                    clientError.type = errorData.type;
+                if (error.code === 'ECONNREFUSED') {
+                    clientError.message = 'Connection refused';
                 }
-                if (errorData.code !== undefined) {
-                    clientError.code = errorData.code;
+                else {
+                    console.error('Unable to parse AxiosError response', { error, x: error.status, y: error.code });
                 }
-                if (errorData.message !== undefined) {
-                    clientError.message = errorData.message;
+            }
+            else {
+                //   console.debug('Parse response', {error: error, data: error.response.data});
+                switch (error.response.status) {
+                    case 404:
+                        clientError.code = 'Not found';
+                        break;
+                    default:
                 }
-                if (errorData.param !== undefined) {
-                    clientError.param = errorData.param;
+                const errorData = error.response.data;
+                if (errorData.error !== undefined) {
+                    // console.debug('Error data', errorData);
+                    if (errorData.error.type !== undefined) {
+                        clientError.type = errorData.error.type;
+                    }
+                    if (errorData.error.code !== undefined) {
+                        clientError.code = errorData.error.code;
+                    }
+                    if (errorData.error.message !== undefined) {
+                        clientError.message = errorData.error.message;
+                    }
+                    if (errorData.error.param !== undefined) {
+                        clientError.param = errorData.error.param;
+                    }
                 }
             }
             return clientError;

package/dist/Model/Adapter/Adapter.d.ts

@@ -9,7 +9,5 @@ export declare class Adapter {
     categoryIds: string[];
     docs: string;
     website: string;
-    static parse(rawAdapter: {
-        [k: string]: any;
-    }): Adapter;
+    static parse(rawAdapter: Record<string, any>): Adapter;
 }

package/dist/Model/Adapter/AdapterConnectionStatus.d.ts

@@ -5,5 +5,5 @@ export declare enum AdapterConnectionStatus {
     Critical = "critical"
 }
 export declare namespace AdapterConnectionStatus {
-    function fromString(input: string): AdapterConnectionStatus;
+    const fromString: (input: string) => AdapterConnectionStatus;
 }

package/dist/Model/Adapter/AdapterConnectionStatus.js

@@ -7,7 +7,7 @@ export var AdapterConnectionStatus;
     AdapterConnectionStatus["Critical"] = "critical";
 })(AdapterConnectionStatus || (AdapterConnectionStatus = {}));
 (function (AdapterConnectionStatus) {
-    function fromString(input) {
+    AdapterConnectionStatus.fromString = (input) => {
         if (input === 'pass') {
             return AdapterConnectionStatus.Healthy;
         }
@@ -22,6 +22,5 @@ export var AdapterConnectionStatus;
             throw new Error('Unable to parse AdapterConnectionStatus from string: Unknown AdapterConnectionStatus "' + input + '"');
         }
         return result;
-    }
-    AdapterConnectionStatus.fromString = fromString;
+    };
 })(AdapterConnectionStatus || (AdapterConnectionStatus = {}));

package/dist/Model/Config.d.ts

@@ -10,7 +10,5 @@ export declare class Config {
     inheritable: boolean;
     sensitive: boolean;
     state: State;
-    static parse(rawConfig: {
-        [k: string]: any;
-    }): Config;
+    static parse(rawConfig: Record<string, any>): Config;
 }

package/dist/Model/Config.js

@@ -1,5 +1,5 @@
-import { State } from './State.js';
 import { Utils } from '../Utils.js';
+import { State } from './State.js';
 export class Config {
     id;
     projectId;

package/dist/Model/DataValueCollection.js

@@ -1,5 +1,5 @@
-import { DataValue } from './DataValue.js';
 import { Utils } from '../Utils.js';
+import { DataValue } from './DataValue.js';
 import { JsonSerializable } from './JsonSerializable.js';
 export class DataValueCollection extends JsonSerializable {
     _values = [];

package/dist/Model/EntityType.d.ts

@@ -13,5 +13,5 @@ export declare enum EntityType {
     ChannelSubscriber = "channel-subscriber"
 }
 export declare namespace EntityType {
-    function fromString(input: string): EntityType;
+    const fromString: (input: string) => EntityType;
 }

package/dist/Model/EntityType.js

@@ -15,12 +15,11 @@ export var EntityType;
     EntityType["ChannelSubscriber"] = "channel-subscriber";
 })(EntityType || (EntityType = {}));
 (function (EntityType) {
-    function fromString(input) {
+    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.fromString = fromString;
+    };
 })(EntityType || (EntityType = {}));

package/dist/Model/Flow/Flow.d.ts

@@ -12,6 +12,6 @@ export declare class Flow extends MetaDataAware implements StateAware {
     /** The maximum number of flows to run at any time (0 = no limit) * */
     parallelLimit: number;
     codeSource: string | null;
-    runCommand: string | null;
+    runStrategy: string | null;
     static parse(rawFlow: any): Flow;
 }

package/dist/Model/Flow/Flow.js

@@ -13,7 +13,7 @@ export class Flow extends MetaDataAware {
     /** The maximum number of flows to run at any time (0 = no limit) * */
     parallelLimit = 0;
     codeSource = null;
-    runCommand = null;
+    runStrategy = null;
     static parse(rawFlow) {
         const flow = new Flow();
         flow.id = rawFlow.id;
@@ -25,7 +25,7 @@ export class Flow extends MetaDataAware {
         flow.state = State.fromString(rawFlow.state);
         flow.parallelLimit = Utils.parseInt(rawFlow.parallel_limit);
         flow.codeSource = rawFlow.code_source;
-        flow.runCommand = rawFlow.run_command;
+        flow.runStrategy = rawFlow.run_strategy;
         if (Object.prototype.hasOwnProperty.call(rawFlow, 'metadata')) {
             flow.metadata = DataValueCollection.fromObject(rawFlow.metadata);
         }

package/dist/Model/Flow/FlowRun.d.ts

@@ -1,6 +1,6 @@
 import { LogLevel } from '../Log/LogLevel.js';
-import { FlowRunPriority } from './FlowRunPriority.js';
 import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { FlowRunPriority } from './FlowRunPriority.js';
 export declare class FlowRun extends MetaDataAware {
     id: string;
     flowId: string;

package/dist/Model/Flow/FlowRun.js

@@ -1,7 +1,7 @@
 import { Utils } from '../../Utils.js';
-import { FlowRunPriority } from './FlowRunPriority.js';
 import { MetaDataAware } from '../../Core/MetaDataAware.js';
 import { DataValueCollection } from '../DataValueCollection.js';
+import { FlowRunPriority } from './FlowRunPriority.js';
 export class FlowRun extends MetaDataAware {
     id;
     // public key: string;

package/dist/Model/Flow/FlowRunHistory.js

@@ -1,5 +1,5 @@
-import { FlowRunStatus } from './FlowRunStatus.js';
 import { Utils } from '../../Utils.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
 export class FlowRunHistory {
     id;
     time;

package/dist/Model/Flow/FlowRunPriority.d.ts

@@ -5,5 +5,5 @@ export declare enum FlowRunPriority {
     High = 3
 }
 export declare namespace FlowRunPriority {
-    function fromString(input: string): FlowRunPriority;
+    const fromString: (input: string) => FlowRunPriority;
 }

package/dist/Model/Flow/FlowRunPriority.js

@@ -7,12 +7,11 @@ export var FlowRunPriority;
     FlowRunPriority[FlowRunPriority["High"] = 3] = "High";
 })(FlowRunPriority || (FlowRunPriority = {}));
 (function (FlowRunPriority) {
-    function fromString(input) {
+    FlowRunPriority.fromString = (input) => {
         const result = Utils.parseEnum(input, FlowRunPriority);
         if (result === null) {
             throw new Error('Unable to parse FlowRunPriority from string: Unknown FlowRunPriority "' + input + '"');
         }
         return result;
-    }
-    FlowRunPriority.fromString = fromString;
+    };
 })(FlowRunPriority || (FlowRunPriority = {}));

package/dist/Model/Flow/FlowRunStatus.d.ts

@@ -8,5 +8,5 @@ export declare enum FlowRunStatus {
     Complete
 }
 export declare namespace FlowRunStatus {
-    function fromString(input: string): FlowRunStatus;
+    const fromString: (input: string) => FlowRunStatus;
 }

package/dist/Model/Flow/FlowRunStatus.js

@@ -10,12 +10,11 @@ export var FlowRunStatus;
     FlowRunStatus[FlowRunStatus["Complete"] = 'complete'] = "Complete";
 })(FlowRunStatus || (FlowRunStatus = {}));
 (function (FlowRunStatus) {
-    function fromString(input) {
+    FlowRunStatus.fromString = (input) => {
         const result = Utils.parseEnum(input, FlowRunStatus);
         if (result === null) {
             throw new Error('Unable to parse FlowRunStatus from string: Unknown FlowRunStatus "' + input + '"');
         }
         return result;
-    }
-    FlowRunStatus.fromString = fromString;
+    };
 })(FlowRunStatus || (FlowRunStatus = {}));

package/dist/Model/Flow/FlowRunSummary.js

@@ -1,6 +1,6 @@
+import { Utils } from '../../Utils.js';
 import { FlowRunStatus } from './FlowRunStatus.js';
 import { FlowRun } from './FlowRun.js';
-import { Utils } from '../../Utils.js';
 export class FlowRunSummary extends FlowRun {
     time;
     runDuration;

package/dist/Model/Flow/FlowSummary.js

@@ -1,6 +1,6 @@
+import { Utils } from '../../Utils.js';
 import { FlowRunStatus } from './FlowRunStatus.js';
 import { Flow } from './Flow.js';
-import { Utils } from '../../Utils.js';
 export class FlowSummary extends Flow {
     status = FlowRunStatus.Unknown;
     latestRun = null;

package/dist/Model/HealthAlert/HealthAlert.d.ts

@@ -1,6 +1,6 @@
+import { DataValueCollection } from '../DataValueCollection.js';
 import { HealthTestType } from './HealthTestType.js';
 import { HealthAlertStatus } from './HealthAlertStatus.js';
-import { DataValueCollection } from '../DataValueCollection.js';
 export declare class HealthAlert {
     id: string;
     scopeId: string;

package/dist/Model/HealthAlert/HealthAlert.js

@@ -1,7 +1,7 @@
-import { HealthTestType } from './HealthTestType.js';
-import { HealthAlertStatus } from './HealthAlertStatus.js';
 import { Utils } from '../../Utils.js';
 import { DataValueCollection } from '../DataValueCollection.js';
+import { HealthTestType } from './HealthTestType.js';
+import { HealthAlertStatus } from './HealthAlertStatus.js';
 export class HealthAlert {
     id;
     scopeId;

package/dist/Model/HealthAlert/HealthAlertStatus.d.ts

@@ -4,5 +4,5 @@ export declare enum HealthAlertStatus {
     FAILED = "fail"
 }
 export declare namespace HealthAlertStatus {
-    function fromString(input: string): HealthAlertStatus;
+    const fromString: (input: string) => HealthAlertStatus;
 }

package/dist/Model/HealthAlert/HealthAlertStatus.js

@@ -6,12 +6,11 @@ export var HealthAlertStatus;
     HealthAlertStatus["FAILED"] = "fail";
 })(HealthAlertStatus || (HealthAlertStatus = {}));
 (function (HealthAlertStatus) {
-    function fromString(input) {
+    HealthAlertStatus.fromString = (input) => {
         const result = Utils.parseEnum(input, HealthAlertStatus);
         if (result === null) {
             throw new Error('Unable to parse HealthAlertStatus from string: Unknown HealthAlertStatus "' + input + '"');
         }
         return result;
-    }
-    HealthAlertStatus.fromString = fromString;
+    };
 })(HealthAlertStatus || (HealthAlertStatus = {}));

package/dist/Model/HealthAlert/HealthTestType.d.ts

@@ -6,5 +6,5 @@ export declare enum HealthTestType {
     FLOW_RUNS_ARE_SUCCESSFUL = "flow_runs_are_successful"
 }
 export declare namespace HealthTestType {
-    function fromString(input: string): HealthTestType;
+    const fromString: (input: string) => HealthTestType;
 }

package/dist/Model/HealthAlert/HealthTestType.js

@@ -8,12 +8,11 @@ export var HealthTestType;
     HealthTestType["FLOW_RUNS_ARE_SUCCESSFUL"] = "flow_runs_are_successful";
 })(HealthTestType || (HealthTestType = {}));
 (function (HealthTestType) {
-    function fromString(input) {
+    HealthTestType.fromString = (input) => {
         const result = Utils.parseEnum(input, HealthTestType);
         if (result === null) {
             throw new Error('Unable to parse HealthTestType from string: Unknown HealthTestType "' + input + '"');
         }
         return result;
-    }
-    HealthTestType.fromString = fromString;
+    };
 })(HealthTestType || (HealthTestType = {}));

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

@@ -9,7 +9,7 @@ export declare enum LogLevel {
     Emergency = "emergency"
 }
 export declare namespace LogLevel {
-    function compare(logLevelA: LogLevel, logLevelB: LogLevel): number;
-    function toNumeric(logLevel: LogLevel): number;
-    function fromString(input: string): LogLevel;
+    const compare: (logLevelA: LogLevel, logLevelB: LogLevel) => number;
+    const toNumeric: (logLevel: LogLevel) => number;
+    const fromString: (input: string) => LogLevel;
 }

package/dist/Model/Log/LogLevel.js

@@ -11,7 +11,7 @@ export var LogLevel;
     LogLevel["Emergency"] = "emergency";
 })(LogLevel || (LogLevel = {}));
 (function (LogLevel) {
-    function compare(logLevelA, logLevelB) {
+    LogLevel.compare = (logLevelA, logLevelB) => {
         const logLevelANumeric = LogLevel.toNumeric(logLevelA);
         const logLevelBNumeric = LogLevel.toNumeric(logLevelB);
         if (logLevelANumeric > logLevelBNumeric) {
@@ -21,9 +21,8 @@ export var LogLevel;
             return -1;
         }
         return 0;
-    }
-    LogLevel.compare = compare;
-    function toNumeric(logLevel) {
+    };
+    LogLevel.toNumeric = (logLevel) => {
         switch (logLevel) {
             case LogLevel.Debug:
                 return 100;
@@ -44,14 +43,12 @@ export var LogLevel;
             default:
                 throw new Error('Unknown log level "' + logLevel + '"');
         }
-    }
-    LogLevel.toNumeric = toNumeric;
-    function fromString(input) {
+    };
+    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.fromString = fromString;
+    };
 })(LogLevel || (LogLevel = {}));

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

@@ -4,5 +4,5 @@ export declare enum LogStatus {
     Resolved = "resolved"
 }
 export declare namespace LogStatus {
-    function fromString(input: string): LogStatus;
+    const fromString: (input: string) => LogStatus;
 }

package/dist/Model/Log/LogStatus.js

@@ -6,12 +6,11 @@ export var LogStatus;
     LogStatus["Resolved"] = "resolved";
 })(LogStatus || (LogStatus = {}));
 (function (LogStatus) {
-    function fromString(input) {
+    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.fromString = fromString;
+    };
 })(LogStatus || (LogStatus = {}));

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

@@ -1,7 +1,7 @@
-import { ChannelType } from './ChannelType.js';
 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;

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

@@ -1,8 +1,8 @@
-import { ChannelType } from './ChannelType.js';
 import { State } from '../../State.js';
 import { Utils } from '../../../Utils.js';
 import { MetaDataAware } from '../../../Core/MetaDataAware.js';
 import { DataValueCollection } from '../../DataValueCollection.js';
+import { ChannelType } from './ChannelType.js';
 export class Channel extends MetaDataAware {
     id;
     ownerId;

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

@@ -6,5 +6,5 @@ export declare enum ChannelType {
     Webhook = "webhook"
 }
 export declare namespace ChannelType {
-    function fromString(input: string): ChannelType;
+    const fromString: (input: string) => ChannelType;
 }

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

@@ -8,12 +8,11 @@ export var ChannelType;
     ChannelType["Webhook"] = "webhook";
 })(ChannelType || (ChannelType = {}));
 (function (ChannelType) {
-    function fromString(input) {
+    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.fromString = fromString;
+    };
 })(ChannelType || (ChannelType = {}));

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

@@ -6,5 +6,5 @@ export declare class SlackChannelData extends ChannelData {
     channel_name: string;
     team_id: string;
     team_name: string;
-    constructor(access_token: string, webhook: string, channel_id: string, channel_name: string, team_id: string, team_name: string);
+    constructor(accessToken: string, webhook: string, channelId: string, channelName: string, teamId: string, teamName: string);
 }

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

@@ -7,13 +7,13 @@ export class SlackChannelData extends ChannelData {
     channel_name;
     team_id;
     team_name;
-    constructor(access_token, webhook, channel_id, channel_name, team_id, team_name) {
+    constructor(accessToken, webhook, channelId, channelName, teamId, teamName) {
         super(ChannelType.Slack);
-        this.access_token = access_token;
+        this.access_token = accessToken;
         this.webhook = webhook;
-        this.channel_id = channel_id;
-        this.channel_name = channel_name;
-        this.team_id = team_id;
-        this.team_name = team_name;
+        this.channel_id = channelId;
+        this.channel_name = channelName;
+        this.team_id = teamId;
+        this.team_name = teamName;
     }
 }

package/dist/Model/Project/CodeDeploy.js

@@ -1,6 +1,6 @@
+import { Utils } from '../../Utils.js';
 import { CodeDeployStatus } from './CodeDeployStatus.js';
 import { ProjectDeployCommit } from './ProjectDeployCommit.js';
-import { Utils } from '../../Utils.js';
 export class CodeDeploy {
     id;
     codeSourceId;

package/dist/Model/Project/CodeDeployStatus.d.ts

@@ -8,5 +8,5 @@ export declare enum CodeDeployStatus {
     Complete = "complete"
 }
 export declare namespace CodeDeployStatus {
-    function fromString(input: string): CodeDeployStatus;
+    const fromString: (input: string) => CodeDeployStatus;
 }

package/dist/Model/Project/CodeDeployStatus.js

@@ -10,12 +10,11 @@ export var CodeDeployStatus;
     CodeDeployStatus["Complete"] = "complete";
 })(CodeDeployStatus || (CodeDeployStatus = {}));
 (function (CodeDeployStatus) {
-    function fromString(input) {
+    CodeDeployStatus.fromString = (input) => {
         const result = Utils.parseEnum(input, CodeDeployStatus);
         if (result === null) {
             throw new Error('Unable to parse CodeDeployStatus from string: Unknown CodeDeployStatus "' + input + '"');
         }
         return result;
-    }
-    CodeDeployStatus.fromString = fromString;
+    };
 })(CodeDeployStatus || (CodeDeployStatus = {}));

package/dist/Model/Project/ProjectEnvironmentType.d.ts

@@ -4,5 +4,5 @@ export declare enum ProjectEnvironmentType {
     Local = "locl"
 }
 export declare namespace ProjectEnvironmentType {
-    function fromString(input: string): ProjectEnvironmentType;
+    const fromString: (input: string) => ProjectEnvironmentType;
 }

package/dist/Model/Project/ProjectEnvironmentType.js

@@ -6,12 +6,11 @@ export var ProjectEnvironmentType;
     ProjectEnvironmentType["Local"] = "locl";
 })(ProjectEnvironmentType || (ProjectEnvironmentType = {}));
 (function (ProjectEnvironmentType) {
-    function fromString(input) {
+    ProjectEnvironmentType.fromString = (input) => {
         const result = Utils.parseEnum(input, ProjectEnvironmentType);
         if (result === null) {
             throw new Error('Unable to parse ProjectEnvironmentType from string: Unknown ProjectEnvironmentType "' + input + '"');
         }
         return result;
-    }
-    ProjectEnvironmentType.fromString = fromString;
+    };
 })(ProjectEnvironmentType || (ProjectEnvironmentType = {}));

package/dist/Model/State.d.ts

@@ -4,5 +4,5 @@ export declare enum State {
     Removed = "removed"
 }
 export declare namespace State {
-    function fromString(input: string): State;
+    const fromString: (input: string) => State;
 }

package/dist/Model/State.js

@@ -6,12 +6,11 @@ export var State;
     State["Removed"] = "removed";
 })(State || (State = {}));
 (function (State) {
-    function fromString(input) {
+    State.fromString = (input) => {
         const result = Utils.parseEnum(input, State);
         if (result === null) {
             throw new Error('Unable to parse State from string: Unknown State "' + input + '"');
         }
         return result;
-    }
-    State.fromString = fromString;
+    };
 })(State || (State = {}));

package/dist/Model/Storage/StorageType.d.ts

@@ -5,5 +5,5 @@ export declare enum StorageType {
     Infrastructure = "infrastructure"
 }
 export declare namespace StorageType {
-    function fromString(input: string): StorageType;
+    const fromString: (input: string) => StorageType;
 }

package/dist/Model/Storage/StorageType.js

@@ -7,12 +7,11 @@ export var StorageType;
     StorageType["Infrastructure"] = "infrastructure";
 })(StorageType || (StorageType = {}));
 (function (StorageType) {
-    function fromString(input) {
+    StorageType.fromString = (input) => {
         const result = Utils.parseEnum(input, StorageType);
         if (result === null) {
             throw new Error('Unable to parse StorageType from string: Unknown StorageType "' + input + '"');
         }
         return result;
-    }
-    StorageType.fromString = fromString;
+    };
 })(StorageType || (StorageType = {}));

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

@@ -4,5 +4,5 @@ export declare enum WorkerInstanceState {
     Error = "Error"
 }
 export declare namespace WorkerInstanceState {
-    function fromString(input: string): WorkerInstanceState;
+    const fromString: (input: string) => WorkerInstanceState;
 }