@attlaz/client 1.77.1

package/dist/Model/Event/EventType.js

@@ -0,0 +1,18 @@
+export var EventType;
+(function (EventType) {
+    /** @deprecated * */
+    EventType["TaskExecutionRequested"] = "TaskExecutionRequested";
+    /** @deprecated * */
+    EventType["TaskExecutionStarted"] = "TaskExecutionStarted";
+    /** @deprecated * */
+    EventType["TaskExecutionFailed"] = "TaskExecutionFailed";
+    /** @deprecated * */
+    EventType["TaskExecutionComplete"] = "TaskExecutionComplete";
+    /** @deprecated * */
+    EventType["TaskExecutionRetry"] = "TaskExecutionRetry";
+    EventType["FlowRunRequested"] = "FlowRunRequested";
+    EventType["FlowRunStarted"] = "FlowRunStarted";
+    EventType["FlowRunFailed"] = "FlowRunFailed";
+    EventType["FlowRunComplete"] = "FlowRunComplete";
+    EventType["FlowRunRetry"] = "FlowRunRetry";
+})(EventType || (EventType = {}));

package/dist/Model/Filter/FilterNode.d.ts

@@ -0,0 +1,18 @@
+import { FilterOperator } from './FilterOperator.js';
+export type FilterPrimitive = string | number | boolean | null;
+export type FilterValue = FilterPrimitive | FilterPrimitive[];
+export interface AndFilterNode {
+    and: FilterNode[];
+}
+export interface OrFilterNode {
+    or: FilterNode[];
+}
+export interface NotFilterNode {
+    not: FilterNode;
+}
+export interface CompareFilterNode {
+    field: string;
+    op: FilterOperator;
+    value: FilterValue;
+}
+export type FilterNode = AndFilterNode | OrFilterNode | NotFilterNode | CompareFilterNode;

package/dist/Model/Filter/FilterNode.js

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

package/dist/Model/Filter/FilterOperator.d.ts

@@ -0,0 +1 @@
+export type FilterOperator = 'eq' | 'neq' | 'in' | 'not_in' | 'lt' | 'lte' | 'gt' | 'gte' | 'is_null' | 'is_not_null' | 'starts_with' | 'ends_with' | 'contains';

package/dist/Model/Filter/FilterOperator.js

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

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

@@ -0,0 +1,17 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Flow extends MetaDataAware implements StateAware {
+    id: string;
+    key: string;
+    projectId: string;
+    isDirect: boolean;
+    state: State;
+    /** The maximum number of flows to run at any time (0 = no limit) * */
+    parallelLimit: number;
+    codeSourceId: string | null;
+    runStrategyId: string | null;
+    runnerPoolId: string | null;
+    static parse(rawFlow: ApiRecord): Flow;
+}

package/dist/Model/Flow/Flow.js

@@ -0,0 +1,27 @@
+import { State } from '../State.js';
+import { Utils } from '../../Utils.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+export class Flow extends MetaDataAware {
+    id;
+    key;
+    projectId;
+    isDirect = false;
+    state = State.Active;
+    /** The maximum number of flows to run at any time (0 = no limit) * */
+    parallelLimit = 0;
+    codeSourceId = null;
+    runStrategyId = null;
+    runnerPoolId = null;
+    static parse(rawFlow) {
+        const flow = MetaDataAware.parseMetaData(new Flow(), rawFlow);
+        flow.key = rawFlow.key;
+        flow.projectId = rawFlow.project;
+        flow.isDirect = Utils.isTrue(rawFlow.is_direct);
+        flow.state = State.fromString(rawFlow.state);
+        flow.parallelLimit = Utils.parseInt(rawFlow.parallel_limit);
+        flow.codeSourceId = rawFlow.code_source;
+        flow.runStrategyId = rawFlow.run_strategy;
+        flow.runnerPoolId = rawFlow.runner_pool;
+        return flow;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+import { LogLevel } from '../Log/LogLevel.js';
+import { LogStreamId } from '../Log/LogStreamId.js';
+import { FlowRunPriority } from './FlowRunPriority.js';
+export declare class FlowRun extends MetaDataAware {
+    id: string;
+    flowId: string;
+    arguments: object | null;
+    projectEnvironmentId: string;
+    triggerId: string;
+    priority: FlowRunPriority;
+    deployId: string;
+    logStreamId: LogStreamId;
+    logLevelCount: Map<LogLevel, number>;
+    logsPurged: boolean;
+    static parse(rawFlowRun: ApiRecord): FlowRun;
+}

package/dist/Model/Flow/FlowRun.js

@@ -0,0 +1,32 @@
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { Utils } from '../../Utils.js';
+import { LogStreamId } from '../Log/LogStreamId.js';
+import { FlowRunPriority } from './FlowRunPriority.js';
+export class FlowRun extends MetaDataAware {
+    id;
+    // public key: string;
+    flowId;
+    arguments;
+    projectEnvironmentId;
+    triggerId;
+    // TODO: implement priority object
+    priority = FlowRunPriority.None;
+    deployId;
+    logStreamId;
+    logLevelCount;
+    logsPurged = false;
+    static parse(rawFlowRun) {
+        const flowRun = MetaDataAware.parseMetaData(new FlowRun(), rawFlowRun);
+        flowRun.id = rawFlowRun.id;
+        flowRun.flowId = rawFlowRun.flow;
+        flowRun.arguments = rawFlowRun.arguments;
+        flowRun.projectEnvironmentId = rawFlowRun.project_environment;
+        flowRun.priority = FlowRunPriority.fromString(rawFlowRun.priority);
+        flowRun.triggerId = rawFlowRun.trigger;
+        flowRun.deployId = rawFlowRun.deploy;
+        flowRun.logStreamId = new LogStreamId(rawFlowRun.log_stream);
+        flowRun.logLevelCount = rawFlowRun.log_level_count;
+        flowRun.logsPurged = Utils.isTrue(rawFlowRun.logs_purged);
+        return flowRun;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { ApiRecord } from '../ApiRecord.js';
+import { FlowRunHistoryStatus } from './FlowRunHistoryStatus.js';
+export declare class FlowRunHistory {
+    id: string;
+    time: Date;
+    status: FlowRunHistoryStatus;
+    static parse(rawFlowRunHistory: ApiRecord): FlowRunHistory;
+}

package/dist/Model/Flow/FlowRunHistory.js

@@ -0,0 +1,14 @@
+import { Utils } from '../../Utils.js';
+import { FlowRunHistoryStatus } from './FlowRunHistoryStatus.js';
+export class FlowRunHistory {
+    id;
+    time;
+    status;
+    static parse(rawFlowRunHistory) {
+        const flowRunHistory = new FlowRunHistory();
+        flowRunHistory.id = rawFlowRunHistory.id;
+        flowRunHistory.time = Utils.parseRawDate(rawFlowRunHistory.time);
+        flowRunHistory.status = FlowRunHistoryStatus.fromString(rawFlowRunHistory.status);
+        return flowRunHistory;
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Status values as stored in flow_run_history (distinct from FlowRunStatus, the derived run state).
+ * Notably `started`/`success` here vs `running`/`complete` on FlowRunStatus — reusing FlowRunStatus
+ * to parse history rows would throw on those two values and silently drop them.
+ */
+export declare enum FlowRunHistoryStatus {
+    Pending = "pending",
+    Started = "started",
+    Success = "success",
+    Failed = "failed",
+    Stopped = "stopped",
+    Canceled = "canceled"
+}
+export declare namespace FlowRunHistoryStatus {
+    const fromString: (input: string) => FlowRunHistoryStatus;
+}

package/dist/Model/Flow/FlowRunHistoryStatus.js

@@ -0,0 +1,24 @@
+import { Utils } from '../../Utils.js';
+/**
+ * Status values as stored in flow_run_history (distinct from FlowRunStatus, the derived run state).
+ * Notably `started`/`success` here vs `running`/`complete` on FlowRunStatus — reusing FlowRunStatus
+ * to parse history rows would throw on those two values and silently drop them.
+ */
+export var FlowRunHistoryStatus;
+(function (FlowRunHistoryStatus) {
+    FlowRunHistoryStatus["Pending"] = "pending";
+    FlowRunHistoryStatus["Started"] = "started";
+    FlowRunHistoryStatus["Success"] = "success";
+    FlowRunHistoryStatus["Failed"] = "failed";
+    FlowRunHistoryStatus["Stopped"] = "stopped";
+    FlowRunHistoryStatus["Canceled"] = "canceled";
+})(FlowRunHistoryStatus || (FlowRunHistoryStatus = {}));
+(function (FlowRunHistoryStatus) {
+    FlowRunHistoryStatus.fromString = (input) => {
+        const result = Utils.parseEnum(input, FlowRunHistoryStatus);
+        if (result === null) {
+            throw new Error('Unable to parse FlowRunHistoryStatus from string: Unknown FlowRunHistoryStatus "' + input + '"');
+        }
+        return result;
+    };
+})(FlowRunHistoryStatus || (FlowRunHistoryStatus = {}));

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

@@ -0,0 +1,16 @@
+import { ApiRecord } from '../ApiRecord.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
+/**
+ * The authoritative lifecycle of a flow run, as derived server-side from its event history
+ * (first-terminal-wins). Unlike FlowRunSummary, which reflects the (eventually-consistent) index
+ * projection, this is computed directly from the history and is safe for control-flow decisions
+ * such as the worker's "is this run already terminal?" tombstone check.
+ */
+export declare class FlowRunLifecycle {
+    id: string;
+    status: FlowRunStatus;
+    requested: Date | null;
+    started: Date | null;
+    ended: Date | null;
+    static parse(rawFlowRunLifecycle: ApiRecord): FlowRunLifecycle;
+}

package/dist/Model/Flow/FlowRunLifecycle.js

@@ -0,0 +1,24 @@
+import { Utils } from '../../Utils.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
+/**
+ * The authoritative lifecycle of a flow run, as derived server-side from its event history
+ * (first-terminal-wins). Unlike FlowRunSummary, which reflects the (eventually-consistent) index
+ * projection, this is computed directly from the history and is safe for control-flow decisions
+ * such as the worker's "is this run already terminal?" tombstone check.
+ */
+export class FlowRunLifecycle {
+    id;
+    status;
+    requested;
+    started;
+    ended;
+    static parse(rawFlowRunLifecycle) {
+        const lifecycle = new FlowRunLifecycle();
+        lifecycle.id = rawFlowRunLifecycle.id;
+        lifecycle.status = FlowRunStatus.fromString(rawFlowRunLifecycle.status);
+        lifecycle.requested = rawFlowRunLifecycle.requested === null || rawFlowRunLifecycle.requested === undefined ? null : Utils.parseRawDate(rawFlowRunLifecycle.requested);
+        lifecycle.started = rawFlowRunLifecycle.started === null || rawFlowRunLifecycle.started === undefined ? null : Utils.parseRawDate(rawFlowRunLifecycle.started);
+        lifecycle.ended = rawFlowRunLifecycle.ended === null || rawFlowRunLifecycle.ended === undefined ? null : Utils.parseRawDate(rawFlowRunLifecycle.ended);
+        return lifecycle;
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare enum FlowRunPriority {
+    None = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3
+}
+export declare namespace FlowRunPriority {
+    const fromString: (input: string) => FlowRunPriority;
+}

package/dist/Model/Flow/FlowRunPriority.js

@@ -0,0 +1,17 @@
+import { Utils } from '../../Utils.js';
+export var FlowRunPriority;
+(function (FlowRunPriority) {
+    FlowRunPriority[FlowRunPriority["None"] = 0] = "None";
+    FlowRunPriority[FlowRunPriority["Low"] = 1] = "Low";
+    FlowRunPriority[FlowRunPriority["Medium"] = 2] = "Medium";
+    FlowRunPriority[FlowRunPriority["High"] = 3] = "High";
+})(FlowRunPriority || (FlowRunPriority = {}));
+(function (FlowRunPriority) {
+    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 || (FlowRunPriority = {}));

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

@@ -0,0 +1,5 @@
+export declare class FlowRunResponse {
+    flowRunRequestId: string;
+    success: boolean;
+    result: any;
+}

package/dist/Model/Flow/FlowRunResponse.js

@@ -0,0 +1,6 @@
+export class FlowRunResponse {
+    flowRunRequestId;
+    success;
+    // retry: boolean;
+    result;
+}

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

@@ -0,0 +1,13 @@
+export declare class FlowRunStats {
+    flowRunId: string;
+    time: Date;
+    memory: number | null;
+    memoryLimit: number | null;
+    cpu: number | null;
+    cpuLimit: number | null;
+    networkOutbound: number | null;
+    networkInbound: number | null;
+    fileRead: number | null;
+    fileWrite: number | null;
+    static parse(raw: any): FlowRunStats;
+}

package/dist/Model/Flow/FlowRunStats.js

@@ -0,0 +1,27 @@
+import { Utils } from '../../Utils.js';
+export class FlowRunStats {
+    flowRunId;
+    time;
+    memory = null;
+    memoryLimit = null;
+    cpu = null;
+    cpuLimit = null;
+    networkOutbound = null;
+    networkInbound = null;
+    fileRead = null;
+    fileWrite = null;
+    static parse(raw) {
+        const flowRunStats = new FlowRunStats();
+        flowRunStats.flowRunId = raw.flow_run;
+        flowRunStats.time = Utils.parseRawDate(raw.time);
+        flowRunStats.memory = raw.memory;
+        flowRunStats.memoryLimit = raw.memory_limit;
+        flowRunStats.cpu = raw.cpu;
+        flowRunStats.cpuLimit = raw.cpu_limit;
+        flowRunStats.networkOutbound = raw.network_outbound;
+        flowRunStats.networkInbound = raw.network_inbound;
+        flowRunStats.fileRead = raw.file_read;
+        flowRunStats.fileWrite = raw.file_write;
+        return flowRunStats;
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare enum FlowRunStatus {
+    Unknown = "unknown",
+    Pending = "pending",
+    Canceled = "canceled",
+    Running = "running",
+    Failed = "failed",
+    Stopped = "stopped",
+    Complete = "complete"
+}
+export declare namespace FlowRunStatus {
+    const fromString: (input: string) => FlowRunStatus;
+}

package/dist/Model/Flow/FlowRunStatus.js

@@ -0,0 +1,20 @@
+import { Utils } from '../../Utils.js';
+export var FlowRunStatus;
+(function (FlowRunStatus) {
+    FlowRunStatus["Unknown"] = "unknown";
+    FlowRunStatus["Pending"] = "pending";
+    FlowRunStatus["Canceled"] = "canceled";
+    FlowRunStatus["Running"] = "running";
+    FlowRunStatus["Failed"] = "failed";
+    FlowRunStatus["Stopped"] = "stopped";
+    FlowRunStatus["Complete"] = "complete";
+})(FlowRunStatus || (FlowRunStatus = {}));
+(function (FlowRunStatus) {
+    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 || (FlowRunStatus = {}));

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

@@ -0,0 +1,17 @@
+import { FlowRunStatus } from './FlowRunStatus.js';
+import { FlowRun } from './FlowRun.js';
+export declare class FlowRunSummary extends FlowRun {
+    time: Date;
+    runDuration: number;
+    pendingDuration: number;
+    status: FlowRunStatus;
+    networkUpload: number | null;
+    networkDownload: number | null;
+    fileRead: number | null;
+    fileWrite: number | null;
+    cpuAverage: number | null;
+    cpuMaximum: number | null;
+    memoryAverage: number | null;
+    memoryMaximum: number | null;
+    static parse(rawFlowRunSummary: any): FlowRunSummary;
+}

package/dist/Model/Flow/FlowRunSummary.js

@@ -0,0 +1,33 @@
+import { Utils } from '../../Utils.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
+import { FlowRun } from './FlowRun.js';
+export class FlowRunSummary extends FlowRun {
+    time;
+    runDuration;
+    pendingDuration;
+    status = FlowRunStatus.Unknown;
+    networkUpload = null;
+    networkDownload = null;
+    fileRead = null;
+    fileWrite = null;
+    cpuAverage = null;
+    cpuMaximum = null;
+    memoryAverage = null;
+    memoryMaximum = null;
+    static parse(rawFlowRunSummary) {
+        const flowRunSummary = FlowRun.parse(rawFlowRunSummary);
+        flowRunSummary.time = Utils.parseRawDate(rawFlowRunSummary.time);
+        flowRunSummary.runDuration = rawFlowRunSummary.run_duration;
+        flowRunSummary.pendingDuration = rawFlowRunSummary.pending_duration;
+        flowRunSummary.status = FlowRunStatus.fromString(rawFlowRunSummary.status);
+        flowRunSummary.networkUpload = rawFlowRunSummary.network_upload;
+        flowRunSummary.networkDownload = rawFlowRunSummary.network_download;
+        flowRunSummary.fileRead = rawFlowRunSummary.file_read;
+        flowRunSummary.fileWrite = rawFlowRunSummary.file_write;
+        flowRunSummary.cpuAverage = rawFlowRunSummary.cpu_average;
+        flowRunSummary.cpuMaximum = rawFlowRunSummary.cpu_maximum;
+        flowRunSummary.memoryAverage = rawFlowRunSummary.memory_average;
+        flowRunSummary.memoryMaximum = rawFlowRunSummary.memory_maximum;
+        return flowRunSummary;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Flow } from './Flow.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
+export declare class FlowSummary extends Flow {
+    projectEnvironment: string;
+    status: FlowRunStatus;
+    latestRun: Date | null;
+    averageRunDuration: number | null;
+    averagePendingDuration: number | null;
+    runCount: number;
+    static parse(rawFlowSummary: any): FlowSummary;
+}

package/dist/Model/Flow/FlowSummary.js

@@ -0,0 +1,21 @@
+import { Utils } from '../../Utils.js';
+import { Flow } from './Flow.js';
+import { FlowRunStatus } from './FlowRunStatus.js';
+export class FlowSummary extends Flow {
+    projectEnvironment;
+    status = FlowRunStatus.Unknown;
+    latestRun = null;
+    averageRunDuration = null;
+    averagePendingDuration = null;
+    runCount = 0;
+    static parse(rawFlowSummary) {
+        const flowSummary = Flow.parse(rawFlowSummary);
+        flowSummary.projectEnvironment = rawFlowSummary.project_environment;
+        flowSummary.status = FlowRunStatus.fromString(rawFlowSummary.status);
+        flowSummary.latestRun = rawFlowSummary.latest_run === null ? null : Utils.parseRawDate(rawFlowSummary.latest_run);
+        flowSummary.averageRunDuration = rawFlowSummary.average_run_duration;
+        flowSummary.averagePendingDuration = rawFlowSummary.average_pending_duration;
+        flowSummary.runCount = rawFlowSummary.run_count;
+        return flowSummary;
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare class FlowTemplate {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+    source: string;
+    requiredTriggers: string[];
+    requiredAdapters: string[];
+    requiredChannels: string[];
+}

package/dist/Model/Flow/FlowTemplate.js

@@ -0,0 +1,10 @@
+export class FlowTemplate {
+    id;
+    name;
+    icon;
+    description;
+    source;
+    requiredTriggers;
+    requiredAdapters;
+    requiredChannels;
+}

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

@@ -0,0 +1,17 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+import { HealthAlertSeverity } from './HealthAlertSeverity.js';
+import { HealthAlertStatus } from './HealthAlertStatus.js';
+import { HealthTestType } from './HealthTestType.js';
+export declare class HealthAlert {
+    id: string;
+    scopeId: string;
+    parentScopeId: string | null;
+    healthTestType: HealthTestType;
+    status: HealthAlertStatus;
+    severity: HealthAlertSeverity;
+    date: Date;
+    updated: Date;
+    data: DataValueCollection;
+    constructor(healthTestType: HealthTestType, status: HealthAlertStatus);
+    static parse(raw: any): HealthAlert;
+}

package/dist/Model/HealthAlert/HealthAlert.js

@@ -0,0 +1,34 @@
+import { Utils } from '../../Utils.js';
+import { DataValueCollection } from '../DataValueCollection.js';
+import { HealthAlertSeverity } from './HealthAlertSeverity.js';
+import { HealthAlertStatus } from './HealthAlertStatus.js';
+import { HealthTestType } from './HealthTestType.js';
+export class HealthAlert {
+    id;
+    scopeId;
+    parentScopeId;
+    healthTestType;
+    status;
+    severity = HealthAlertSeverity.ERROR;
+    date;
+    updated;
+    data;
+    constructor(healthTestType, status) {
+        this.healthTestType = healthTestType;
+        this.status = status;
+        this.date = new Date();
+        this.data = new DataValueCollection();
+    }
+    static parse(raw) {
+        const healthAlert = new HealthAlert(HealthTestType.fromString(raw.health_test_type), HealthAlertStatus.fromString(raw.status));
+        healthAlert.id = raw.id;
+        healthAlert.scopeId = raw.scope;
+        healthAlert.parentScopeId = raw.parent_scope;
+        // severity defaults to ERROR — defensive for older API responses that don't yet send it.
+        healthAlert.severity = raw.severity ? HealthAlertSeverity.fromString(raw.severity) : HealthAlertSeverity.ERROR;
+        healthAlert.date = Utils.parseRawDate(raw.date);
+        healthAlert.updated = Utils.parseRawDate(raw.updated);
+        healthAlert.data = DataValueCollection.fromObject(raw.data);
+        return healthAlert;
+    }
+}

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

@@ -0,0 +1,8 @@
+export declare enum HealthAlertSeverity {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+export declare namespace HealthAlertSeverity {
+    const fromString: (input: string) => HealthAlertSeverity;
+}

package/dist/Model/HealthAlert/HealthAlertSeverity.js

@@ -0,0 +1,16 @@
+import { Utils } from '../../Utils.js';
+export var HealthAlertSeverity;
+(function (HealthAlertSeverity) {
+    HealthAlertSeverity["INFO"] = "info";
+    HealthAlertSeverity["WARNING"] = "warning";
+    HealthAlertSeverity["ERROR"] = "error";
+})(HealthAlertSeverity || (HealthAlertSeverity = {}));
+(function (HealthAlertSeverity) {
+    HealthAlertSeverity.fromString = (input) => {
+        const result = Utils.parseEnum(input, HealthAlertSeverity);
+        if (result === null) {
+            throw new Error('Unable to parse HealthAlertSeverity from string: Unknown HealthAlertSeverity "' + input + '"');
+        }
+        return result;
+    };
+})(HealthAlertSeverity || (HealthAlertSeverity = {}));

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

@@ -0,0 +1,8 @@
+export declare enum HealthAlertStatus {
+    PASSED = "pass",
+    SKIPPED = "skip",
+    FAILED = "fail"
+}
+export declare namespace HealthAlertStatus {
+    const fromString: (input: string) => HealthAlertStatus;
+}

package/dist/Model/HealthAlert/HealthAlertStatus.js

@@ -0,0 +1,16 @@
+import { Utils } from '../../Utils.js';
+export var HealthAlertStatus;
+(function (HealthAlertStatus) {
+    HealthAlertStatus["PASSED"] = "pass";
+    HealthAlertStatus["SKIPPED"] = "skip";
+    HealthAlertStatus["FAILED"] = "fail";
+})(HealthAlertStatus || (HealthAlertStatus = {}));
+(function (HealthAlertStatus) {
+    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 || (HealthAlertStatus = {}));

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

@@ -0,0 +1,14 @@
+export declare enum HealthTestType {
+    PROJECT_ENVIRONMENT_HAS_WORKERS = "project_environment_has_workers",
+    QUEUE_FLOW_IS_HEALTHY = "queue_flow_is_healthy",
+    WORKER_IS_UP_TO_DATE = "worker_is_up_to_date",
+    ADAPTER_CONNECTION_IS_HEALTHY = "adapter_connection_is_healthy",
+    FLOW_RUNS_ARE_SUCCESSFUL = "flow_runs_are_successful",
+    STORAGE_CACHE_USAGE_WITHIN_LIMIT = "storage_cache_usage_within_limit",
+    STORAGE_PERSISTENT_USAGE_WITHIN_LIMIT = "storage_persistent_usage_within_limit",
+    STORAGE_VAULT_USAGE_WITHIN_LIMIT = "storage_vault_usage_within_limit",
+    STORAGE_INFRASTRUCTURE_USAGE_WITHIN_LIMIT = "storage_infrastructure_usage_within_limit"
+}
+export declare namespace HealthTestType {
+    const fromString: (input: string) => HealthTestType;
+}

package/dist/Model/HealthAlert/HealthTestType.js

@@ -0,0 +1,22 @@
+import { Utils } from '../../Utils.js';
+export var HealthTestType;
+(function (HealthTestType) {
+    HealthTestType["PROJECT_ENVIRONMENT_HAS_WORKERS"] = "project_environment_has_workers";
+    HealthTestType["QUEUE_FLOW_IS_HEALTHY"] = "queue_flow_is_healthy";
+    HealthTestType["WORKER_IS_UP_TO_DATE"] = "worker_is_up_to_date";
+    HealthTestType["ADAPTER_CONNECTION_IS_HEALTHY"] = "adapter_connection_is_healthy";
+    HealthTestType["FLOW_RUNS_ARE_SUCCESSFUL"] = "flow_runs_are_successful";
+    HealthTestType["STORAGE_CACHE_USAGE_WITHIN_LIMIT"] = "storage_cache_usage_within_limit";
+    HealthTestType["STORAGE_PERSISTENT_USAGE_WITHIN_LIMIT"] = "storage_persistent_usage_within_limit";
+    HealthTestType["STORAGE_VAULT_USAGE_WITHIN_LIMIT"] = "storage_vault_usage_within_limit";
+    HealthTestType["STORAGE_INFRASTRUCTURE_USAGE_WITHIN_LIMIT"] = "storage_infrastructure_usage_within_limit";
+})(HealthTestType || (HealthTestType = {}));
+(function (HealthTestType) {
+    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 || (HealthTestType = {}));

package/dist/Model/Inbox/InboxMessage.d.ts

@@ -0,0 +1,10 @@
+export declare class InboxMessage {
+    id: string;
+    userId: string;
+    type: string;
+    subject: string;
+    body: string;
+    time: Date;
+    acknowledged: boolean;
+    static parse(rawNotification: any): InboxMessage;
+}