@hahnpro/hpc-api 2026.4.2 → 2026.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2026.4.2",
+  "version": "2026.4.4",
   "description": "Module for easy access to the HahnPRO Cloud API",
   "license": "MIT",
   "author": {
@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "@microsoft/fetch-event-source": "2.0.1",
-    "axios": "1.14.0",
+    "axios": "1.15.0",
     "eventsource": "4.1.0",
     "jose": "5.10.0",
     "jwt-decode": "4.0.0",

package/src/lib/interfaces/alert.interface.d.ts

@@ -4,7 +4,7 @@ export interface Alert {
     name: string;
     description?: string;
     tsRefs: TimeSeriesReference[];
-    status: string;
+    status: AlertStatus;
     condition: AlertCondition;
     messageTmpl?: string;
     tags?: string[];
@@ -24,11 +24,24 @@ export interface AlertCondition {
     period?: string;
     stopPeriod?: string;
 }
+export interface AlertMessageTemplate {
+    label: string;
+    text: string;
+}
 export interface TimeSeriesReference {
     alias?: string;
     id: string;
     field: string;
 }
+export interface UpdatedField {
+    alias?: string;
+    field: string;
+    value: string | number;
+}
+export declare enum AlertStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
 export declare enum AlertType {
     Threshold = "threshold",
     Relative = "relative",
@@ -41,3 +54,20 @@ export declare enum AlertLevel {
     OK = "OK",
     ANY = "ANY"
 }
+export declare const DEFAULT_THRESHOLD_CONDITION: {
+    level: AlertLevel;
+    range: number[];
+    operator: string;
+};
+export declare const DEFAULT_RELATIVE_CONDITION: {
+    level: AlertLevel;
+    operator: string;
+    change: string;
+    value: number;
+    period: string;
+};
+export declare const DEFAULT_DEADMAN_CONDITION: {
+    level: AlertLevel;
+    period: string;
+    stopPeriod: string;
+};

package/src/lib/interfaces/alert.interface.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlertLevel = exports.AlertType = void 0;
+exports.DEFAULT_DEADMAN_CONDITION = exports.DEFAULT_RELATIVE_CONDITION = exports.DEFAULT_THRESHOLD_CONDITION = exports.AlertLevel = exports.AlertType = exports.AlertStatus = void 0;
+var AlertStatus;
+(function (AlertStatus) {
+    AlertStatus["ACTIVE"] = "ACTIVE";
+    AlertStatus["INACTIVE"] = "INACTIVE";
+})(AlertStatus || (exports.AlertStatus = AlertStatus = {}));
 var AlertType;
 (function (AlertType) {
     AlertType["Threshold"] = "threshold";
@@ -15,3 +20,20 @@ var AlertLevel;
     AlertLevel["OK"] = "OK";
     AlertLevel["ANY"] = "ANY";
 })(AlertLevel || (exports.AlertLevel = AlertLevel = {}));
+exports.DEFAULT_THRESHOLD_CONDITION = {
+    level: AlertLevel.CRITICAL,
+    range: [10],
+    operator: 'greater',
+};
+exports.DEFAULT_RELATIVE_CONDITION = {
+    level: AlertLevel.CRITICAL,
+    operator: 'greater',
+    change: 'absolute',
+    value: 10,
+    period: '1m',
+};
+exports.DEFAULT_DEADMAN_CONDITION = {
+    level: AlertLevel.CRITICAL,
+    period: '60s',
+    stopPeriod: '10m',
+};

package/src/lib/interfaces/api.interface.d.ts

@@ -9,3 +9,20 @@ export interface Api {
     updatedBy?: Author;
     owner?: Owner;
 }
+export interface ObjectIdLike {
+    toString(): string;
+}
+export interface Change {
+    action: ChangeAction;
+    affectedObject: string;
+    subject: any;
+    value: any;
+    accepted: boolean;
+    priority: number;
+}
+export declare enum ChangeAction {
+    ADDED = 0,
+    REMOVED = 1,
+    CHANGED = 2
+}
+export type ChangeSubject = 'tags' | 'readPermissions' | 'readWritePermissions';

package/src/lib/interfaces/api.interface.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeAction = void 0;
+var ChangeAction;
+(function (ChangeAction) {
+    ChangeAction[ChangeAction["ADDED"] = 0] = "ADDED";
+    ChangeAction[ChangeAction["REMOVED"] = 1] = "REMOVED";
+    ChangeAction[ChangeAction["CHANGED"] = 2] = "CHANGED";
+})(ChangeAction || (exports.ChangeAction = ChangeAction = {}));

package/src/lib/interfaces/asset.interface.d.ts

@@ -1,4 +1,9 @@
-import { Author, Content, Owner } from '.';
+import type { Change, ChangeSubject } from './api.interface';
+import type { Author } from './author.interface';
+import type { Content } from './content.interface';
+import type { EventLevel } from './event.interface';
+import type { Owner } from './owner.interface';
+import type { SearchResultItem } from './search.interface';
 export interface AssetType {
     id?: string;
     name: string;
@@ -63,11 +68,11 @@ export type AssetRevision = Asset & {
 export type Attachment = Content;
 export interface EventCause {
     cause: string;
-    level: string;
+    level: EventLevel;
 }
 export interface EventLevelOverride {
     [assetId: string]: {
-        [eventCause: string]: string;
+        [eventCause: string]: EventLevel;
     };
 }
 export interface Template {
@@ -87,3 +92,13 @@ export interface AssetTimeSeriesValue {
     assetId: string;
     timeSeriesValue: number;
 }
+export type AssetSubject = ChangeSubject | 'parent' | 'type';
+export interface AssetChange extends Change {
+    subject: AssetSubject;
+    value: string;
+}
+export interface AssetTypeSearchResult extends SearchResultItem {
+    isSystemAssetType: boolean;
+    isGlobalAssetType: boolean;
+    owner?: Owner;
+}

package/src/lib/interfaces/audit.interface.d.ts

@@ -0,0 +1,19 @@
+import type { Api } from './api.interface';
+export interface Audit extends Api {
+    id: string;
+    date: string;
+    serviceId: string;
+    service: string;
+    userId: string;
+    user: string;
+    correlationId: string;
+    ip: string;
+    host: string;
+    url: string;
+    method: string;
+    controller: string;
+    action: string;
+    resourceId?: string;
+    resourceName?: string;
+    statusCode?: number;
+}

package/src/lib/interfaces/audit.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/interfaces/billing.interface.d.ts

@@ -0,0 +1,72 @@
+import { OwnerType, type Owner } from './owner.interface';
+import { EventType } from './resource.interface';
+export interface Billing {
+    id: string;
+    type: OwnerType;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    billedRegularly: RegularlyBilledResources;
+    billedOnce?: Record<string, OnceBilledResources>;
+    subscription?: BillingSubscription;
+    lastBilled?: string;
+}
+export interface RegularlyBilledResources {
+    assets: Record<string, BillingResource>;
+    storage: Record<string, BillingResource>;
+    timeseries: Record<string, BillingResource>;
+    user: Record<string, BillingResource>;
+}
+export interface OnceBilledResources {
+    completion_tokens: number;
+    events: number;
+    flow_credits: number;
+    prompt_tokens: number;
+    tasks: number;
+    ts_values: number;
+}
+export interface BillingResource {
+    statuses: {
+        timestamp: string;
+        status: EventType;
+    }[];
+    size?: number;
+}
+export interface BillingSubscription {
+    azureId: string;
+    planId: string;
+    startDate: string;
+    isActive: boolean;
+}
+export interface BillingEvent {
+    owner: Owner;
+    sizes?: number[];
+}
+export type BillingValues = {
+    assets: number;
+    storage: number;
+    timeseries: number;
+    user: number;
+} & OnceBilledResources;
+export interface AzureBillingEvent {
+    resourceId: string;
+    quantity: number;
+    dimension: string;
+    effectiveStartTime: string;
+    planId: string;
+    status?: string;
+}
+export interface AzureBillingResult {
+    count: number;
+    result: AzureBillingEvent[];
+}
+export declare enum BillingResourceType {
+    AI_TOKENS = "ai_tokens",
+    ASSETS = "assets",
+    EVENTS = "events",
+    FLOW_CREDITS = "flow_credits",
+    STORAGE = "storage",
+    TASKS = "tasks",
+    TIMESERIES = "timeseries",
+    TS_VALUES = "ts_values",
+    USER = "user"
+}

package/src/lib/interfaces/billing.interface.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingResourceType = void 0;
+var BillingResourceType;
+(function (BillingResourceType) {
+    BillingResourceType["AI_TOKENS"] = "ai_tokens";
+    BillingResourceType["ASSETS"] = "assets";
+    BillingResourceType["EVENTS"] = "events";
+    BillingResourceType["FLOW_CREDITS"] = "flow_credits";
+    BillingResourceType["STORAGE"] = "storage";
+    BillingResourceType["TASKS"] = "tasks";
+    BillingResourceType["TIMESERIES"] = "timeseries";
+    BillingResourceType["TS_VALUES"] = "ts_values";
+    BillingResourceType["USER"] = "user";
+})(BillingResourceType || (exports.BillingResourceType = BillingResourceType = {}));

package/src/lib/interfaces/content.interface.d.ts

@@ -1,4 +1,8 @@
-import { Author, Owner, Storage } from '.';
+import type { Change, ChangeSubject } from './api.interface';
+import type { Author } from './author.interface';
+import type { Owner } from './owner.interface';
+import type { SearchResultItem } from './search.interface';
+import type { Storage } from './storage.interface';
 export interface Content {
     id?: string;
     fileId: string;
@@ -19,6 +23,10 @@ export interface Content {
     deletedAt?: string;
     analysis?: string | ContentAnalysis;
 }
+export interface ContentSearchResult extends SearchResultItem {
+    filename?: string;
+    description?: string;
+}
 export declare class ContentAnalysis {
     id: string;
     contentId: string;
@@ -30,6 +38,29 @@ export declare class ContentAnalysis {
         text?: string;
     }[];
 }
+export interface ContentChange extends Change {
+    subject: ChangeSubject;
+    value: string;
+}
+export declare enum IndexingStatus {
+    COMPLETED = "completed",
+    FAILED = "failed",
+    NOT_TRIGGERED = "notTriggered",
+    QUEUED = "queued",
+    PARTIALLY_FAILED = "partiallyFailed"
+}
+export interface IndexingStatusData {
+    id: string;
+    status: IndexingStatus;
+}
+export type ReindexStatusSsePayload = {
+    type: 'status';
+    content: IndexingStatusData[];
+} | {
+    type: 'error';
+    message: string;
+    status?: number;
+};
 export declare enum ReturnType {
     TEXT = 0,
     JSON = 1,

package/src/lib/interfaces/content.interface.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturnType = exports.ContentAnalysis = void 0;
+exports.ReturnType = exports.IndexingStatus = exports.ContentAnalysis = void 0;
 class ContentAnalysis {
 }
 exports.ContentAnalysis = ContentAnalysis;
+var IndexingStatus;
+(function (IndexingStatus) {
+    IndexingStatus["COMPLETED"] = "completed";
+    IndexingStatus["FAILED"] = "failed";
+    IndexingStatus["NOT_TRIGGERED"] = "notTriggered";
+    IndexingStatus["QUEUED"] = "queued";
+    IndexingStatus["PARTIALLY_FAILED"] = "partiallyFailed";
+})(IndexingStatus || (exports.IndexingStatus = IndexingStatus = {}));
 var ReturnType;
 (function (ReturnType) {
     ReturnType[ReturnType["TEXT"] = 0] = "TEXT";

package/src/lib/interfaces/edge-device.interface.d.ts

@@ -0,0 +1,28 @@
+export interface EdgeDeviceResult {
+    xml?: {
+        wkadaten: {
+            element: {
+                value: string | number;
+            }[];
+        };
+    };
+    json?: Record<string, {
+        Wert: number;
+    }>;
+    webIO?: WebIOData;
+}
+export interface EdgeDeviceRequestResponse {
+    name: string;
+}
+export interface WebIOData {
+    iostate: {
+        input: {
+            number: number;
+            state: number;
+        }[];
+        output: {
+            number: number;
+            state: number;
+        }[];
+    };
+}

package/src/lib/interfaces/edge-device.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/interfaces/endpoint.interface.d.ts

@@ -4,13 +4,9 @@ export interface Endpoint {
     id?: string;
     name: string;
     description?: string;
-    status: string;
-    config: {
-        type: string;
-        url?: string;
-        authToken: string;
-        recipients?: string[];
-    };
+    tags?: string[];
+    status: NotificationEndpointStatus;
+    config: EndpointConfig;
     spamProtection?: string;
     pauseInterval?: number;
     readPermissions: string[];
@@ -22,14 +18,24 @@ export interface Endpoint {
     updatedAt?: string;
     deletedAt?: string;
 }
+export interface EndpointConfig {
+    type: string;
+    url?: string;
+    authToken?: string;
+    recipients?: string[];
+    message?: string;
+}
+export type NotificationEndpoint = Endpoint;
+export type NotificationLogType = 'info' | 'error';
 export interface EndpointLog {
     id?: string;
     endpoint: string;
-    type?: 'info' | 'error';
+    type?: NotificationLogType;
     data?: string;
     group?: string;
     updatedAt?: string;
 }
+export type NotificationEndpointLog = EndpointLog;
 export interface NotificationPayload {
     subject: string;
     message: string;
@@ -46,3 +52,36 @@ export interface NotificationPayload {
     assetName?: string;
     assetLink?: string;
 }
+interface PreviousNotification {
+    subject: string;
+    timestamp: string;
+}
+export interface AdditionalNotificationData {
+    level?: string;
+    group?: string;
+    trigger?: string;
+    timestamp?: string;
+    previousNotification?: PreviousNotification;
+    eventLink?: string;
+    assetLink?: string;
+}
+export interface SearchEndpointResult {
+    readonly id: string;
+    readonly name: string;
+}
+export declare enum NotificationEndpointStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export declare enum NotificationEndpointType {
+    POST = "post",
+    FLOW = "flow",
+    EMAIL = "email",
+    TEAMS = "teams"
+}
+export declare enum NotificationEndpointSpamProtection {
+    NONE = "none",
+    ASSET = "asset",
+    MESSAGE = "message"
+}
+export {};

package/src/lib/interfaces/endpoint.interface.js

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationEndpointSpamProtection = exports.NotificationEndpointType = exports.NotificationEndpointStatus = void 0;
+var NotificationEndpointStatus;
+(function (NotificationEndpointStatus) {
+    NotificationEndpointStatus["ACTIVE"] = "ACTIVE";
+    NotificationEndpointStatus["INACTIVE"] = "INACTIVE";
+})(NotificationEndpointStatus || (exports.NotificationEndpointStatus = NotificationEndpointStatus = {}));
+var NotificationEndpointType;
+(function (NotificationEndpointType) {
+    NotificationEndpointType["POST"] = "post";
+    NotificationEndpointType["FLOW"] = "flow";
+    NotificationEndpointType["EMAIL"] = "email";
+    NotificationEndpointType["TEAMS"] = "teams";
+})(NotificationEndpointType || (exports.NotificationEndpointType = NotificationEndpointType = {}));
+var NotificationEndpointSpamProtection;
+(function (NotificationEndpointSpamProtection) {
+    NotificationEndpointSpamProtection["NONE"] = "none";
+    NotificationEndpointSpamProtection["ASSET"] = "asset";
+    NotificationEndpointSpamProtection["MESSAGE"] = "message";
+})(NotificationEndpointSpamProtection || (exports.NotificationEndpointSpamProtection = NotificationEndpointSpamProtection = {}));

package/src/lib/interfaces/event.interface.d.ts

@@ -1,4 +1,5 @@
 import { Author, Owner, Resource } from '.';
+import type { EventLevelOverride } from './asset.interface';
 export interface Event extends Resource {
     data?: Record<string, any>;
     assetRef?: string;
@@ -7,18 +8,20 @@ export interface Event extends Resource {
     tsRef?: string;
     eventRef?: string;
     cause?: string;
-    level: EventLevel;
+    level: string;
     group?: string;
     owner?: Owner;
     createdBy?: Author;
     updatedBy?: Author;
 }
-export declare enum EventLevel {
-    Info = "INFO",
-    OK = "OK",
-    Warning = "WARNING",
-    Critical = "CRITICAL"
-}
+export declare const eventLevels: readonly ["WARNING", "OK", "CRITICAL", "INFO"];
+export type EventLevel = (typeof eventLevels)[number];
+export declare const EventLevel: {
+    readonly Warning: "WARNING";
+    readonly OK: "OK";
+    readonly Critical: "CRITICAL";
+    readonly Info: "INFO";
+};
 export type CreateEventDto = Omit<Event, 'id' | 'assetRef$name' | 'createdAt' | 'updatedAt'>;
 export interface EventCountByAsset {
     id: string;
@@ -28,3 +31,9 @@ export interface EventCountByAsset {
     eventId?: string;
     eventName?: string;
 }
+export declare class EventLevelOverrideWrapper {
+    private readonly data;
+    constructor(data: EventLevelOverride);
+    setEventLevel(assetId: string, eventCause: string, level: EventLevel): void;
+    getEventLevel(assetId: string, eventCause?: string): EventLevel;
+}

package/src/lib/interfaces/event.interface.js

@@ -1,10 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventLevel = void 0;
-var EventLevel;
-(function (EventLevel) {
-    EventLevel["Info"] = "INFO";
-    EventLevel["OK"] = "OK";
-    EventLevel["Warning"] = "WARNING";
-    EventLevel["Critical"] = "CRITICAL";
-})(EventLevel || (exports.EventLevel = EventLevel = {}));
+exports.EventLevelOverrideWrapper = exports.EventLevel = exports.eventLevels = void 0;
+exports.eventLevels = ['WARNING', 'OK', 'CRITICAL', 'INFO'];
+exports.EventLevel = {
+    Warning: 'WARNING',
+    OK: 'OK',
+    Critical: 'CRITICAL',
+    Info: 'INFO',
+};
+class EventLevelOverrideWrapper {
+    constructor(data) {
+        this.data = data ?? {};
+    }
+    setEventLevel(assetId, eventCause, level) {
+        if (!this.data[assetId]) {
+            this.data[assetId] = {};
+        }
+        this.data[assetId][eventCause] = level;
+    }
+    getEventLevel(assetId, eventCause) {
+        eventCause = eventCause?.replace(/\s+/g, ' ').trim();
+        if (this.data[assetId]?.[eventCause]) {
+            return this.data[assetId][eventCause];
+        }
+        return null;
+    }
+}
+exports.EventLevelOverrideWrapper = EventLevelOverrideWrapper;

package/src/lib/interfaces/flow-deployment-status.interface.d.ts

@@ -0,0 +1,32 @@
+export declare enum FlowDeploymentStatus {
+    CREATED = "created",
+    DEPLOYED = "deployed",
+    DEPLOYING = "deploying",
+    DEPLOYMENT_FAILED = "deployment failed",
+    DEPLOYMENT_QUEUED = "deployment queued",
+    DELETED = "deleted",
+    DELETING = "deleting",
+    DELETING_FAILED = "deleting failed",
+    GENERATED = "generated",
+    GENERATING = "generating",
+    GENERATING_FAILED = "generating failed",
+    GENERATING_QUEUED = "generating queued",
+    INACTIVE = "inactive",
+    PAUSED = "paused",
+    RUNNING = "running",
+    STOPPED = "stopped",
+    STOPPING = "stopping",
+    TIMEOUT = "timeout",
+    UNKNOWN = "unknown",
+    UPDATED = "updated",
+    UPDATING = "updating",
+    UPDATING_FAILED = "updating failed",
+    UPGRADED = "upgraded",
+    UPGRADING = "upgrading",
+    UPGRADING_FAILED = "upgrading failed"
+}
+export declare const RUNNING_STATES: FlowDeploymentStatus[];
+export declare const STOPPED_STATES: FlowDeploymentStatus[];
+export declare const PROCESSING_STATES: FlowDeploymentStatus[];
+export declare const ERROR_STATES: FlowDeploymentStatus[];
+export declare const UNKOWN_STATES: FlowDeploymentStatus[];

package/src/lib/interfaces/flow-deployment-status.interface.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKOWN_STATES = exports.ERROR_STATES = exports.PROCESSING_STATES = exports.STOPPED_STATES = exports.RUNNING_STATES = exports.FlowDeploymentStatus = void 0;
+var FlowDeploymentStatus;
+(function (FlowDeploymentStatus) {
+    FlowDeploymentStatus["CREATED"] = "created";
+    FlowDeploymentStatus["DEPLOYED"] = "deployed";
+    FlowDeploymentStatus["DEPLOYING"] = "deploying";
+    FlowDeploymentStatus["DEPLOYMENT_FAILED"] = "deployment failed";
+    FlowDeploymentStatus["DEPLOYMENT_QUEUED"] = "deployment queued";
+    FlowDeploymentStatus["DELETED"] = "deleted";
+    FlowDeploymentStatus["DELETING"] = "deleting";
+    FlowDeploymentStatus["DELETING_FAILED"] = "deleting failed";
+    FlowDeploymentStatus["GENERATED"] = "generated";
+    FlowDeploymentStatus["GENERATING"] = "generating";
+    FlowDeploymentStatus["GENERATING_FAILED"] = "generating failed";
+    FlowDeploymentStatus["GENERATING_QUEUED"] = "generating queued";
+    FlowDeploymentStatus["INACTIVE"] = "inactive";
+    FlowDeploymentStatus["PAUSED"] = "paused";
+    FlowDeploymentStatus["RUNNING"] = "running";
+    FlowDeploymentStatus["STOPPED"] = "stopped";
+    FlowDeploymentStatus["STOPPING"] = "stopping";
+    FlowDeploymentStatus["TIMEOUT"] = "timeout";
+    FlowDeploymentStatus["UNKNOWN"] = "unknown";
+    FlowDeploymentStatus["UPDATED"] = "updated";
+    FlowDeploymentStatus["UPDATING"] = "updating";
+    FlowDeploymentStatus["UPDATING_FAILED"] = "updating failed";
+    FlowDeploymentStatus["UPGRADED"] = "upgraded";
+    FlowDeploymentStatus["UPGRADING"] = "upgrading";
+    FlowDeploymentStatus["UPGRADING_FAILED"] = "upgrading failed";
+})(FlowDeploymentStatus || (exports.FlowDeploymentStatus = FlowDeploymentStatus = {}));
+exports.RUNNING_STATES = [FlowDeploymentStatus.RUNNING];
+exports.STOPPED_STATES = [FlowDeploymentStatus.STOPPED, FlowDeploymentStatus.PAUSED];
+exports.PROCESSING_STATES = [
+    FlowDeploymentStatus.CREATED,
+    FlowDeploymentStatus.DEPLOYED,
+    FlowDeploymentStatus.DEPLOYING,
+    FlowDeploymentStatus.DEPLOYMENT_QUEUED,
+    FlowDeploymentStatus.DELETED,
+    FlowDeploymentStatus.DELETING,
+    FlowDeploymentStatus.GENERATED,
+    FlowDeploymentStatus.GENERATING,
+    FlowDeploymentStatus.GENERATING_QUEUED,
+    FlowDeploymentStatus.STOPPING,
+    FlowDeploymentStatus.UPDATED,
+    FlowDeploymentStatus.UPDATING,
+    FlowDeploymentStatus.UPGRADED,
+    FlowDeploymentStatus.UPGRADING,
+];
+exports.ERROR_STATES = [
+    FlowDeploymentStatus.DEPLOYMENT_FAILED,
+    FlowDeploymentStatus.DELETING_FAILED,
+    FlowDeploymentStatus.GENERATING_FAILED,
+    FlowDeploymentStatus.UPDATING_FAILED,
+    FlowDeploymentStatus.UPGRADING_FAILED,
+    FlowDeploymentStatus.TIMEOUT,
+];
+exports.UNKOWN_STATES = [FlowDeploymentStatus.INACTIVE, FlowDeploymentStatus.UNKNOWN];