@masterteam/escalation 0.0.1

package/fesm2022/masterteam-escalation.mjs

@@ -0,0 +1,1190 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, computed, signal, linkedSignal, effect, Component } from '@angular/core';
+import { Card } from '@masterteam/components/card';
+import { StructureBuilder } from '@masterteam/structure-builder';
+import { Action, Selector, State, Store, select } from '@ngxs/store';
+import { HttpClient } from '@angular/common/http';
+import { of } from 'rxjs';
+import { tap, catchError, finalize } from 'rxjs/operators';
+import * as i1 from '@angular/forms';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { DynamicForm } from '@masterteam/forms/dynamic-form';
+import { Skeleton } from 'primeng/skeleton';
+
+class SetModuleInfo {
+    moduleType;
+    moduleId;
+    parentModuleType;
+    parentModuleId;
+    parentPath;
+    static type = '[Escalation] Set Module Info';
+    constructor(moduleType, moduleId, parentModuleType, parentModuleId, parentPath) {
+        this.moduleType = moduleType;
+        this.moduleId = moduleId;
+        this.parentModuleType = parentModuleType;
+        this.parentModuleId = parentModuleId;
+        this.parentPath = parentPath;
+    }
+}
+class GetEscalation {
+    static type = '[Escalation] Get Escalation';
+}
+class GetFormulaProperties {
+    static type = '[Escalation] Get Formula Properties';
+}
+class GetGroups {
+    static type = '[Escalation] Get Groups';
+}
+class GetRolesForModule {
+    static type = '[Escalation] Get Roles For Module';
+}
+class GetStep {
+    stepId;
+    static type = '[Escalation] Get Step';
+    constructor(stepId) {
+        this.stepId = stepId;
+    }
+}
+class ValidateFlow {
+    static type = '[Escalation] Validate Flow';
+}
+class CreateStep {
+    payload;
+    static type = '[Escalation] Create Step';
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+class UpdateStep {
+    stepId;
+    payload;
+    static type = '[Escalation] Update Step';
+    constructor(stepId, payload) {
+        this.stepId = stepId;
+        this.payload = payload;
+    }
+}
+class CreateConnection {
+    payload;
+    static type = '[Escalation] Create Connection';
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+class UpdateConnection {
+    connectionId;
+    payload;
+    static type = '[Escalation] Update Connection';
+    constructor(connectionId, payload) {
+        this.connectionId = connectionId;
+        this.payload = payload;
+    }
+}
+class PublishEscalation {
+    isPublished;
+    static type = '[Escalation] Publish Escalation';
+    constructor(isPublished) {
+        this.isPublished = isPublished;
+    }
+}
+class DeleteStep {
+    stepId;
+    static type = '[Escalation] Delete Step';
+    constructor(stepId) {
+        this.stepId = stepId;
+    }
+}
+class DeleteConnection {
+    connectionId;
+    static type = '[Escalation] Delete Connection';
+    constructor(connectionId) {
+        this.connectionId = connectionId;
+    }
+}
+
+function startLoading(ctx, loadingName) {
+    const { loadingActive, errors } = ctx.getState();
+    if (!loadingActive.includes(loadingName)) {
+        ctx.patchState({
+            loadingActive: [...loadingActive, loadingName],
+        });
+    }
+    if (errors && errors[loadingName]) {
+        const { [loadingName]: _removed, ...rest } = errors;
+        ctx.patchState({ errors: rest });
+    }
+}
+function endLoading(ctx, loadingName) {
+    const { loadingActive } = ctx.getState();
+    ctx.patchState({
+        loadingActive: loadingActive.filter((name) => name !== loadingName),
+    });
+}
+function setLoadingError(ctx, loadingName, message) {
+    const { errors } = ctx.getState();
+    ctx.patchState({
+        errors: { ...errors, [loadingName]: message },
+    });
+}
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+const DEFAULT_STATE = {
+    moduleType: null,
+    moduleId: null,
+    escalation: null,
+    formulaProperties: [],
+    groups: [],
+    roles: [],
+    selectedStep: null,
+    isFlowValid: null,
+    loadingActive: [],
+    errors: {},
+};
+let EscalationState = class EscalationState {
+    http = inject(HttpClient);
+    baseUrl = 'EscalationSchemas';
+    groupsUrl = 'identity/Groups';
+    rolesUrl = 'identity/roles/scopes';
+    static moduleId(state) {
+        return state.moduleId;
+    }
+    static moduleType(state) {
+        return state.moduleType;
+    }
+    static escalation(state) {
+        return state.escalation;
+    }
+    static formulaProperties(state) {
+        return state.formulaProperties;
+    }
+    static groups(state) {
+        return state.groups;
+    }
+    static roles(state) {
+        return state.roles;
+    }
+    static selectedStep(state) {
+        return state.selectedStep;
+    }
+    static isFlowValid(state) {
+        return state.isFlowValid;
+    }
+    static stepsSchema(state) {
+        return state.escalation?.stepsSchema ?? [];
+    }
+    static connections(state) {
+        return state.escalation?.connections ?? [];
+    }
+    static isLoadingFactory(state) {
+        return (loadingName) => state.loadingActive.includes(loadingName);
+    }
+    static errorFactory(state) {
+        return (loadingName) => state.errors?.[loadingName] ?? null;
+    }
+    setModuleInfo(ctx, action) {
+        let parentPath = '';
+        if (action.parentModuleType && action.parentModuleId) {
+            parentPath = `/${action.parentModuleType}/${action.parentModuleId}`;
+        }
+        else if (action.parentPath) {
+            parentPath = action.parentPath;
+        }
+        ctx.patchState({
+            moduleType: action.moduleType,
+            moduleId: action.moduleId,
+            parentModuleType: action.parentModuleType ?? null,
+            parentModuleId: action.parentModuleId ?? null,
+            parentPath: parentPath ?? '',
+        });
+    }
+    getEscalation(ctx, _action) {
+        startLoading(ctx, 'getEscalation');
+        const state = ctx.getState();
+        const { moduleId, parentPath, moduleType } = state;
+        if (!moduleId) {
+            const message = 'Module ID is not set';
+            setLoadingError(ctx, 'getEscalation', message);
+            endLoading(ctx, 'getEscalation');
+            return of(null);
+        }
+        return this.http
+            .get(`${this.baseUrl}${parentPath}/${moduleType}/${moduleId}`, {
+            params: { Mode: 'edit' },
+        })
+            .pipe(tap((response) => {
+            const escalation = response?.data ?? null;
+            ctx.patchState({ escalation });
+        }), catchError((error) => {
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to load escalation';
+            setLoadingError(ctx, 'getEscalation', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'getEscalation')));
+    }
+    getFormulaProperties(ctx, _action) {
+        startLoading(ctx, 'getFormulaProperties');
+        const state = ctx.getState();
+        const moduleId = state.moduleId;
+        if (!moduleId) {
+            const message = 'Module ID is not set';
+            setLoadingError(ctx, 'getFormulaProperties', message);
+            endLoading(ctx, 'getFormulaProperties');
+            return of(null);
+        }
+        return this.http
+            .get(`${this.baseUrl}/processFormulaProperties/${moduleId}`)
+            .pipe(tap((response) => {
+            const formulaProperties = Array.isArray(response?.data)
+                ? response.data
+                : [];
+            ctx.patchState({ formulaProperties });
+        }), catchError((error) => {
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to load formula properties';
+            setLoadingError(ctx, 'getFormulaProperties', message);
+            return of([]);
+        }), finalize(() => endLoading(ctx, 'getFormulaProperties')));
+    }
+    getGroups(ctx, _action) {
+        const state = ctx.getState();
+        if (state.groups.length) {
+            return of(state.groups);
+        }
+        startLoading(ctx, 'getGroups');
+        return this.http.get(this.groupsUrl).pipe(tap((response) => {
+            const groups = Array.isArray(response?.data) ? response.data : [];
+            ctx.patchState({ groups });
+        }), catchError((error) => {
+            const message = error?.error?.message ?? error?.message ?? 'Failed to load groups';
+            setLoadingError(ctx, 'getGroups', message);
+            return of([]);
+        }), finalize(() => endLoading(ctx, 'getGroups')));
+    }
+    getRolesForModule(ctx, _action) {
+        const state = ctx.getState();
+        const { moduleType, moduleId } = state;
+        if (!moduleType || !moduleId) {
+            const message = 'Module type and module ID must be set';
+            setLoadingError(ctx, 'getRolesForModule', message);
+            return of([]);
+        }
+        startLoading(ctx, 'getRolesForModule');
+        return this.http
+            .get(`${this.rolesUrl}/${moduleType}/${moduleId}`, {
+            params: { inherited: 'true' },
+        })
+            .pipe(tap((response) => {
+            const roles = Array.isArray(response?.data) ? response.data : [];
+            ctx.patchState({ roles });
+        }), catchError((error) => {
+            const message = error?.error?.message ?? error?.message ?? 'Failed to load roles';
+            setLoadingError(ctx, 'getRolesForModule', message);
+            return of([]);
+        }), finalize(() => endLoading(ctx, 'getRolesForModule')));
+    }
+    getStep(ctx, action) {
+        startLoading(ctx, 'getStep');
+        return this.http
+            .get(`${this.baseUrl}/step/${action.stepId}`, {
+            params: { Mode: 'edit' },
+        })
+            .pipe(tap((response) => {
+            const selectedStep = response?.data ?? null;
+            ctx.patchState({ selectedStep });
+        }), catchError((error) => {
+            const message = error?.error?.message ?? error?.message ?? 'Failed to load step';
+            setLoadingError(ctx, 'getStep', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'getStep')));
+    }
+    validateFlow(ctx, _action) {
+        startLoading(ctx, 'validateFlow');
+        const state = ctx.getState();
+        const { moduleId, parentPath, moduleType } = state;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'validateFlow', message);
+            endLoading(ctx, 'validateFlow');
+            return of(null);
+        }
+        return this.http
+            .get(`${this.baseUrl}/requestSchema${parentPath}/${moduleType}/${moduleId}/validity`)
+            .pipe(tap((response) => {
+            const isFlowValid = response?.data ?? null;
+            ctx.patchState({ isFlowValid });
+        }), catchError((error) => {
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to validate flow';
+            setLoadingError(ctx, 'validateFlow', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'validateFlow')));
+    }
+    createStep(ctx, action) {
+        const state = ctx.getState();
+        const { moduleId, parentPath, moduleType } = state;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'createStep', message);
+            return of(null);
+        }
+        const tempId = -Date.now();
+        const tempStep = {
+            ...action.payload,
+            id: tempId,
+            loading: true,
+        };
+        if (state.escalation) {
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    stepsSchema: [...state.escalation.stepsSchema, tempStep],
+                },
+            });
+        }
+        startLoading(ctx, 'createStep');
+        return this.http
+            .post(`${this.baseUrl}${parentPath}/${moduleType}/${moduleId}/steps`, action.payload)
+            .pipe(tap((response) => {
+            const createdStep = response?.data;
+            const currentState = ctx.getState();
+            if (createdStep && currentState.escalation) {
+                const updatedSteps = currentState.escalation.stepsSchema.map((step) => step.id === tempId ? { ...createdStep, loading: false } : step);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: updatedSteps,
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const filteredSteps = currentState.escalation.stepsSchema.filter((step) => step.id !== tempId);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: filteredSteps,
+                    },
+                });
+            }
+            const message = error?.error?.message ?? error?.message ?? 'Failed to create step';
+            setLoadingError(ctx, 'createStep', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'createStep')));
+    }
+    updateStep(ctx, action) {
+        const state = ctx.getState();
+        const moduleId = state.moduleId;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'updateStep', message);
+            return of(null);
+        }
+        if (state.escalation) {
+            const updatedSteps = state.escalation.stepsSchema.map((step) => step.id === action.stepId ? { ...step, loading: true } : step);
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    stepsSchema: updatedSteps,
+                },
+            });
+        }
+        startLoading(ctx, 'updateStep');
+        return this.http
+            .put(`${this.baseUrl}/steps/${action.stepId}`, action.payload)
+            .pipe(tap((response) => {
+            const updatedStep = response?.data;
+            const currentState = ctx.getState();
+            if (updatedStep && currentState.escalation) {
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: currentState.escalation.stepsSchema.map((step) => step.id === updatedStep.id
+                            ? { ...updatedStep, loading: false }
+                            : step),
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const errorSteps = currentState.escalation.stepsSchema.map((step) => step.id === action.stepId ? { ...step, loading: false } : step);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: errorSteps,
+                    },
+                });
+            }
+            const message = error?.error?.message ?? error?.message ?? 'Failed to update step';
+            setLoadingError(ctx, 'updateStep', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'updateStep')));
+    }
+    createConnection(ctx, action) {
+        const state = ctx.getState();
+        const { moduleId, parentPath, moduleType } = state;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'createConnection', message);
+            return of(null);
+        }
+        const tempId = -Date.now();
+        const tempConnection = {
+            ...action.payload,
+            id: tempId,
+            loading: true,
+            source: action.payload.sourceStepId,
+            target: action.payload.targetStepId,
+        };
+        if (state.escalation) {
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    connections: [...state.escalation.connections, tempConnection],
+                },
+            });
+        }
+        startLoading(ctx, 'createConnection');
+        return this.http
+            .post(`${this.baseUrl}${parentPath}/${moduleType}/${moduleId}/connections`, action.payload)
+            .pipe(tap((response) => {
+            const createdConnection = response?.data;
+            const currentState = ctx.getState();
+            if (createdConnection && currentState.escalation) {
+                const updatedConnections = currentState.escalation.connections.map((conn) => conn.id === tempId
+                    ? { ...createdConnection, loading: false }
+                    : conn);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: updatedConnections,
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const filteredConnections = currentState.escalation.connections.filter((conn) => conn.id !== tempId);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: filteredConnections,
+                    },
+                });
+            }
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to create connection';
+            setLoadingError(ctx, 'createConnection', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'createConnection')));
+    }
+    updateConnection(ctx, action) {
+        const state = ctx.getState();
+        const moduleId = state.moduleId;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'updateConnection', message);
+            return of(null);
+        }
+        if (state.escalation) {
+            const updatedConnections = state.escalation.connections.map((conn) => conn.id === action.connectionId ? { ...conn, loading: true } : conn);
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    connections: updatedConnections,
+                },
+            });
+        }
+        startLoading(ctx, 'updateConnection');
+        return this.http
+            .put(`${this.baseUrl}/connections/${action.connectionId}`, action.payload)
+            .pipe(tap((response) => {
+            const updatedConnection = response?.data;
+            const currentState = ctx.getState();
+            if (updatedConnection && currentState.escalation) {
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: currentState.escalation.connections.map((conn) => conn.id === updatedConnection.id
+                            ? { ...updatedConnection, loading: false }
+                            : conn),
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const errorConnections = currentState.escalation.connections.map((conn) => conn.id === action.connectionId
+                    ? { ...conn, loading: false }
+                    : conn);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: errorConnections,
+                    },
+                });
+            }
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to update connection';
+            setLoadingError(ctx, 'updateConnection', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'updateConnection')));
+    }
+    publishEscalation(ctx, action) {
+        startLoading(ctx, 'publishEscalation');
+        const state = ctx.getState();
+        const { moduleId, parentPath, moduleType } = state;
+        if (!moduleId) {
+            const message = 'Escalation ID is not set';
+            setLoadingError(ctx, 'publishEscalation', message);
+            endLoading(ctx, 'publishEscalation');
+            return of(null);
+        }
+        return this.http
+            .put(`${this.baseUrl}${parentPath}/${moduleType}/${moduleId}/publish`, { IsPublished: action.isPublished })
+            .pipe(tap((response) => {
+            const publishedData = response?.data;
+            if (publishedData && state.escalation) {
+                ctx.patchState({
+                    escalation: {
+                        ...state.escalation,
+                        isPublished: publishedData.isPublished,
+                        isValid: publishedData.isValid,
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to publish escalation';
+            setLoadingError(ctx, 'publishEscalation', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'publishEscalation')));
+    }
+    deleteStep(ctx, action) {
+        const state = ctx.getState();
+        if (state.escalation) {
+            const updatedSteps = state.escalation.stepsSchema.map((step) => step.id == action.stepId ? { ...step, loading: true } : step);
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    stepsSchema: updatedSteps,
+                },
+            });
+        }
+        startLoading(ctx, 'deleteStep');
+        return this.http
+            .delete(`${this.baseUrl}/steps/${action.stepId}`)
+            .pipe(tap(() => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: currentState.escalation.stepsSchema.filter((step) => step.id != action.stepId),
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const errorSteps = currentState.escalation.stepsSchema.map((step) => step.id == action.stepId ? { ...step, loading: false } : step);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        stepsSchema: errorSteps,
+                    },
+                });
+            }
+            const message = error?.error?.message ?? error?.message ?? 'Failed to delete step';
+            setLoadingError(ctx, 'deleteStep', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'deleteStep')));
+    }
+    deleteConnection(ctx, action) {
+        const state = ctx.getState();
+        if (state.escalation) {
+            const updatedConnections = state.escalation.connections.map((conn) => conn.id == action.connectionId ? { ...conn, loading: true } : conn);
+            ctx.patchState({
+                escalation: {
+                    ...state.escalation,
+                    connections: updatedConnections,
+                },
+            });
+        }
+        startLoading(ctx, 'deleteConnection');
+        return this.http
+            .delete(`${this.baseUrl}/connections/${action.connectionId}`)
+            .pipe(tap(() => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: currentState.escalation.connections.filter((conn) => conn.id != action.connectionId),
+                    },
+                });
+            }
+        }), catchError((error) => {
+            const currentState = ctx.getState();
+            if (currentState.escalation) {
+                const errorConnections = currentState.escalation.connections.map((conn) => conn.id == action.connectionId
+                    ? { ...conn, loading: false }
+                    : conn);
+                ctx.patchState({
+                    escalation: {
+                        ...currentState.escalation,
+                        connections: errorConnections,
+                    },
+                });
+            }
+            const message = error?.error?.message ??
+                error?.message ??
+                'Failed to delete connection';
+            setLoadingError(ctx, 'deleteConnection', message);
+            return of(null);
+        }), finalize(() => endLoading(ctx, 'deleteConnection')));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationState });
+};
+__decorate([
+    Action(SetModuleInfo)
+], EscalationState.prototype, "setModuleInfo", null);
+__decorate([
+    Action(GetEscalation)
+], EscalationState.prototype, "getEscalation", null);
+__decorate([
+    Action(GetFormulaProperties)
+], EscalationState.prototype, "getFormulaProperties", null);
+__decorate([
+    Action(GetGroups)
+], EscalationState.prototype, "getGroups", null);
+__decorate([
+    Action(GetRolesForModule)
+], EscalationState.prototype, "getRolesForModule", null);
+__decorate([
+    Action(GetStep)
+], EscalationState.prototype, "getStep", null);
+__decorate([
+    Action(ValidateFlow)
+], EscalationState.prototype, "validateFlow", null);
+__decorate([
+    Action(CreateStep)
+], EscalationState.prototype, "createStep", null);
+__decorate([
+    Action(UpdateStep)
+], EscalationState.prototype, "updateStep", null);
+__decorate([
+    Action(CreateConnection)
+], EscalationState.prototype, "createConnection", null);
+__decorate([
+    Action(UpdateConnection)
+], EscalationState.prototype, "updateConnection", null);
+__decorate([
+    Action(PublishEscalation)
+], EscalationState.prototype, "publishEscalation", null);
+__decorate([
+    Action(DeleteStep)
+], EscalationState.prototype, "deleteStep", null);
+__decorate([
+    Action(DeleteConnection)
+], EscalationState.prototype, "deleteConnection", null);
+__decorate([
+    Selector()
+], EscalationState, "moduleId", null);
+__decorate([
+    Selector()
+], EscalationState, "moduleType", null);
+__decorate([
+    Selector()
+], EscalationState, "escalation", null);
+__decorate([
+    Selector()
+], EscalationState, "formulaProperties", null);
+__decorate([
+    Selector()
+], EscalationState, "groups", null);
+__decorate([
+    Selector()
+], EscalationState, "roles", null);
+__decorate([
+    Selector()
+], EscalationState, "selectedStep", null);
+__decorate([
+    Selector()
+], EscalationState, "isFlowValid", null);
+__decorate([
+    Selector()
+], EscalationState, "stepsSchema", null);
+__decorate([
+    Selector()
+], EscalationState, "connections", null);
+__decorate([
+    Selector()
+], EscalationState, "isLoadingFactory", null);
+__decorate([
+    Selector()
+], EscalationState, "errorFactory", null);
+EscalationState = __decorate([
+    State({
+        name: 'escalation',
+        defaults: DEFAULT_STATE,
+    })
+], EscalationState);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationState, decorators: [{
+            type: Injectable
+        }], propDecorators: { setModuleInfo: [], getEscalation: [], getFormulaProperties: [], getGroups: [], getRolesForModule: [], getStep: [], validateFlow: [], createStep: [], updateStep: [], createConnection: [], updateConnection: [], publishEscalation: [], deleteStep: [], deleteConnection: [] } });
+
+class EscalationFacade {
+    store = inject(Store);
+    moduleType = select(EscalationState.moduleType);
+    moduleId = select(EscalationState.moduleId);
+    escalation = select(EscalationState.escalation);
+    formulaProperties = select(EscalationState.formulaProperties);
+    groups = select(EscalationState.groups);
+    roles = select(EscalationState.roles);
+    selectedStep = select(EscalationState.selectedStep);
+    isFlowValid = select(EscalationState.isFlowValid);
+    steps = select(EscalationState.stepsSchema);
+    connections = select(EscalationState.connections);
+    isLoading(loadingName) {
+        const loadingFactory = select(EscalationState.isLoadingFactory);
+        return computed(() => loadingFactory()(loadingName));
+    }
+    error(loadingName) {
+        const errorFactory = select(EscalationState.errorFactory);
+        return computed(() => errorFactory()(loadingName));
+    }
+    setModuleInfo(moduleType, moduleId, parentModuleType, parentModuleId, parentPath) {
+        return this.store.dispatch(new SetModuleInfo(moduleType, moduleId, parentModuleType, parentModuleId, parentPath));
+    }
+    loadEscalation() {
+        return this.store.dispatch(new GetEscalation());
+    }
+    loadFormulaProperties() {
+        return this.store.dispatch(new GetFormulaProperties());
+    }
+    loadGroups() {
+        return this.store.dispatch(new GetGroups());
+    }
+    loadRolesForModule() {
+        return this.store.dispatch(new GetRolesForModule());
+    }
+    loadStep(stepId) {
+        return this.store.dispatch(new GetStep(stepId));
+    }
+    validateFlow() {
+        return this.store.dispatch(new ValidateFlow());
+    }
+    createStep(payload) {
+        return this.store.dispatch(new CreateStep(payload));
+    }
+    updateStep(stepId, payload) {
+        return this.store.dispatch(new UpdateStep(stepId, payload));
+    }
+    createConnection(payload) {
+        return this.store.dispatch(new CreateConnection(payload));
+    }
+    updateConnection(connectionId, payload) {
+        return this.store.dispatch(new UpdateConnection(connectionId, payload));
+    }
+    publishEscalation(isPublished) {
+        return this.store.dispatch(new PublishEscalation(isPublished));
+    }
+    deleteStep(stepId) {
+        return this.store.dispatch(new DeleteStep(stepId));
+    }
+    deleteConnection(connectionId) {
+        return this.store.dispatch(new DeleteConnection(connectionId));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationFacade, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationFacade, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationFacade, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+// shared/models/api.model.ts
+
+class EscalationBuilder {
+    escalationFacade = inject(EscalationFacade);
+    groups = this.escalationFacade.groups;
+    roles = this.escalationFacade.roles;
+    escalation = this.escalationFacade.escalation;
+    loading = this.escalationFacade.isLoading('getEscalation');
+    loadingStep = this.escalationFacade.isLoading('getStep');
+    selectedStep = this.escalationFacade.selectedStep;
+    nodeFields = signal({
+        name: 'name',
+    }, ...(ngDevMode ? [{ debugName: "nodeFields" }] : []));
+    nodeFormControl = new FormControl();
+    isEditingInitialNode = signal(false, ...(ngDevMode ? [{ debugName: "isEditingInitialNode" }] : []));
+    availableNodes = [
+        {
+            id: 'FormStep',
+            label: 'New Step',
+            name: {
+                en: 'New Step',
+                ar: ' خطوة جديدة',
+            },
+            targetType: '1',
+            icon: 'general.plus-circle',
+            color: '#000000',
+        },
+    ];
+    // Base form sections - defined once for reusability
+    baseNameFields = {
+        key: 'settings',
+        type: 'none',
+        bodyClass: 'space-y-2',
+        fields: [
+            {
+                key: 'name.en',
+                label: 'Name (English)',
+                placeholder: 'Enter name in English',
+                cssClass: 'w-full',
+                required: true,
+            },
+            {
+                key: 'name.ar',
+                label: 'Name (Arabic)',
+                placeholder: 'Enter name in Arabic',
+                cssClass: 'w-full',
+                required: true,
+            },
+        ],
+    };
+    // Approver section with dynamic options
+    approverSection = computed(() => ({
+        key: 'settings',
+        type: 'header',
+        label: 'Approver',
+        headerClass: 'rounded-t-xl bg-slate-50 px-4 py-3 text-sm font-semibold text-slate-900 border border-slate-200 border-b-0',
+        bodyClass: 'rounded-b-xl border border-slate-200 p-4 space-y-3',
+        cssClass: ' ',
+        fields: [
+            {
+                key: 'targetType',
+                type: 'radio-button',
+                orientation: 'horizontal',
+                defaultValue: '1',
+                options: [
+                    { label: 'Group', value: '1' },
+                    { label: 'Role', value: '2' },
+                ],
+                optionLabel: 'title',
+                optionValue: 'value',
+                placeholder: 'Enter Role',
+                cssClass: 'flex items-center gap-6 text-sm text-slate-700',
+                required: true,
+            },
+            {
+                key: 'group',
+                label: 'Select',
+                placeholder: 'Select group',
+                cssClass: 'mt-2 pt-3 border-t border-slate-200 w-full',
+                required: true,
+                type: 'select',
+                options: this.groups(),
+                optionLabel: 'title',
+                optionValue: 'id',
+                relations: [{ key: 'targetType', value: '1', action: 'show' }],
+            },
+            {
+                key: 'role',
+                label: 'Select',
+                placeholder: 'Enter target value',
+                cssClass: 'mt-2 pt-3 border-t border-slate-200 w-full',
+                required: true,
+                type: 'select',
+                options: this.roles(),
+                optionLabel: 'title',
+                optionValue: 'id',
+                relations: [{ key: 'targetType', value: '2', action: 'show' }],
+            },
+        ],
+    }), ...(ngDevMode ? [{ debugName: "approverSection" }] : []));
+    slaSection = {
+        key: 'slaSection',
+        type: 'none',
+        bodyClass: 'space-y-1',
+        fields: [
+            {
+                key: 'sla',
+                label: 'SLA',
+                placeholder: 'Enter SLA',
+                cssClass: 'w-full',
+                required: true,
+            },
+        ],
+    };
+    // Dynamic form configuration using linkedSignal
+    // Automatically rebuilds when isEditingInitialNode changes
+    nodeForm = linkedSignal(() => {
+        const sections = [this.baseNameFields];
+        // Conditionally include approver and SLA sections based on isEditingInitialNode
+        // Initial nodes only show name fields
+        if (!this.isEditingInitialNode()) {
+            sections.push(this.approverSection());
+            sections.push(this.slaSection);
+        }
+        return {
+            sections,
+            layout: {},
+        };
+    });
+    // Sample connection form configuration
+    connectionForm = signal({
+        sections: [
+            {
+                key: 'basic',
+                label: 'Basic Information',
+                type: 'none',
+                cssClass: 'p-4',
+                order: 1,
+                fields: [
+                    {
+                        key: 'priority',
+                        label: 'Priority',
+                    },
+                ],
+            },
+        ],
+    }, ...(ngDevMode ? [{ debugName: "connectionForm" }] : []));
+    // Nodes currently in the flow
+    steps = computed(() => {
+        return this.escalationFacade.steps().map((step) => ({
+            ...step,
+            color: '#000000',
+        }));
+    }, ...(ngDevMode ? [{ debugName: "steps" }] : []));
+    // Connections between nodes
+    connections = computed(() => {
+        return this.escalationFacade.connections().map((connection) => ({
+            ...connection,
+            from: connection.source,
+            to: connection.target,
+        }));
+    }, ...(ngDevMode ? [{ debugName: "connections" }] : []));
+    // Node Actions
+    nodeActions = signal([
+        {
+            key: 'edit',
+            icon: 'general.edit-05',
+            variant: 'outlined',
+            size: 'small',
+            tooltip: 'Edit',
+        },
+        {
+            key: 'delete',
+            icon: 'general.trash-01',
+            variant: 'outlined',
+            size: 'small',
+            severity: 'danger',
+            tooltip: 'Delete',
+        },
+    ], ...(ngDevMode ? [{ debugName: "nodeActions" }] : []));
+    constructor() {
+        // Effect to watch selectedStep and patch form when it changes
+        effect(() => {
+            const step = this.selectedStep();
+            if (step) {
+                // Patch form with complete step data
+                this.nodeFormControl.patchValue({
+                    name: step.name,
+                    targetType: step.targetType || '1',
+                    group: step.targetType === '1' ? parseInt(step.targetValue) : null,
+                    role: step.targetType === '2' ? step.targetValue : null,
+                    sla: step.sla,
+                });
+                console.log('Form patched with step data:', step);
+            }
+        });
+    }
+    onNodeActionsEvent(event) {
+        console.log('Node action event:', event);
+    }
+    clearForm() {
+        // Reset isEditingInitialNode flag
+        this.isEditingInitialNode.set(false);
+        // Reset form to default values
+        this.nodeFormControl.reset({
+            name: { en: '', ar: '' },
+            targetType: '1',
+            group: null,
+            role: null,
+            sla: 0,
+        });
+        console.log('Form cleared for new step');
+    }
+    onStructureAction(event) {
+        console.log('Structure action received:', event);
+        switch (event.action) {
+            case 'createNode':
+                if (event.data) {
+                    // Get form values
+                    const formValue = this.nodeFormControl.value;
+                    // Prepare step payload without properties
+                    const stepPayload = {
+                        name: formValue.name || { en: 'New Step', ar: 'خطوة جديدة' },
+                        targetType: formValue.targetType,
+                        targetValue: formValue.targetType === '1' ? formValue.group : formValue.role,
+                        sla: formValue.sla || 0,
+                    };
+                    // Create step via facade
+                    this.escalationFacade.createStep(stepPayload).subscribe({
+                        next: () => {
+                            console.log('Step created successfully:', stepPayload);
+                        },
+                        error: (error) => {
+                            console.error('Failed to create step:', error);
+                        },
+                    });
+                }
+                break;
+            case 'startUpdating':
+                if (event.data) {
+                    this.clearForm();
+                    const stepId = event.data.id;
+                    // Set the flag based on whether node is initial
+                    // This will trigger nodeForm to rebuild automatically via linkedSignal
+                    this.isEditingInitialNode.set(!!event.data.isInitial);
+                    // Load step data
+                    this.escalationFacade.loadStep(stepId);
+                }
+                break;
+            case 'startCreating':
+                // Reset form for new step
+                this.clearForm();
+                break;
+            case 'updateNode':
+                if (event.data) {
+                    // Get form values
+                    const formValue = this.nodeFormControl.value;
+                    const stepId = event.data.id;
+                    // Prepare step payload
+                    const stepPayload = {
+                        name: formValue.name || event.data.name,
+                        targetType: formValue.targetType,
+                        targetValue: formValue.targetType === '1' ? formValue.group : formValue.role,
+                        sla: formValue.sla || event.data.sla,
+                    };
+                    // Update step via facade
+                    this.escalationFacade.updateStep(stepId, stepPayload).subscribe({
+                        next: () => {
+                            console.log('Step updated successfully:', stepPayload);
+                        },
+                        error: (error) => {
+                            console.error('Failed to update step:', error);
+                        },
+                    });
+                }
+                break;
+            case 'deleteNode':
+                if (event.data) {
+                    const nodeIdToDelete = event.data.id;
+                    // Delete step from store
+                    this.escalationFacade.deleteStep(nodeIdToDelete).subscribe({
+                        next: () => {
+                            console.log('Node deleted:', nodeIdToDelete);
+                        },
+                        error: (error) => {
+                            console.error('Failed to delete node:', error);
+                        },
+                    });
+                }
+                break;
+            case 'createConnection':
+                if (event.data) {
+                    // Create connection in store
+                    const connectionPayload = {
+                        sourceStepId: event.data.from,
+                        targetStepId: event.data.to,
+                        priority: event.data.priority ?? 1,
+                        formula: event.data.formula ?? [],
+                    };
+                    this.escalationFacade.createConnection(connectionPayload).subscribe({
+                        next: () => {
+                            console.log('Connection created:', event.data);
+                        },
+                        error: (error) => {
+                            console.error('Failed to create connection:', error);
+                        },
+                    });
+                }
+                break;
+            case 'updateConnection':
+                if (event.data) {
+                    // Update connection in store
+                    const connectionId = event.data.id;
+                    const updatePayload = {
+                        sourceStepId: event.data.from,
+                        targetStepId: event.data.to,
+                        priority: event.data.priority ?? 1,
+                        formula: event.data.formula ?? [],
+                    };
+                    this.escalationFacade
+                        .updateConnection(connectionId, updatePayload)
+                        .subscribe({
+                        next: () => {
+                            console.log('Connection updated:', event.data);
+                        },
+                        error: (error) => {
+                            console.error('Failed to update connection:', error);
+                        },
+                    });
+                }
+                break;
+            case 'deleteConnection':
+                if (event.data) {
+                    const connectionIdToDelete = event.data.id;
+                    // Delete connection from store
+                    this.escalationFacade
+                        .deleteConnection(connectionIdToDelete)
+                        .subscribe({
+                        next: () => {
+                            console.log('Connection deleted:', connectionIdToDelete);
+                        },
+                        error: (error) => {
+                            console.error('Failed to delete connection:', error);
+                        },
+                    });
+                }
+                break;
+            default:
+                console.warn('Unknown structure action:', event.action);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationBuilder, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.3", type: EscalationBuilder, isStandalone: true, selector: "mt-escalation-builder", ngImport: i0, template: "<mt-card class=\"h-[calc(100vh---spacing(26))] relative\" id=\"escalationCard\">\n  @if (!loading()) {\n    <mt-structure-builder\n      class=\"flex-1\"\n      [availableNodes]=\"availableNodes\"\n      [connectionForm]=\"connectionForm()\"\n      [nodeActions]=\"nodeActions()\"\n      (nodeActionsEvent)=\"onNodeActionsEvent($event)\"\n      [nodes]=\"steps()\"\n      [connections]=\"connections()\"\n      (action)=\"onStructureAction($event)\"\n      [addModalType]=\"'drawer'\"\n      [addModalStyleClass]=\"'!w-[25rem] !absolute !shadow-none'\"\n      [updateModalStyleClass]=\"'!w-[25rem] !absolute !shadow-none'\"\n      [addModalHeader]=\"'Add Step'\"\n      [updateModalHeader]=\"'Edit Step'\"\n      [appendTo]=\"'escalationCard'\"\n      [nodeFields]=\"nodeFields()\"\n    >\n      <ng-template\n        #nodeDialog\n        let-close=\"close\"\n        let-save=\"save\"\n        let-node=\"node\"\n      >\n        <div class=\"p-4\">\n          @if (loadingStep()) {\n            <!-- Loading skeleton -->\n            <div class=\"space-y-4\">\n              <!-- Form fields skeleton -->\n              <div class=\"space-y-4\">\n                <div>\n                  <p-skeleton\n                    width=\"8rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"8rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"10rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"3rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"6rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"4rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n              </div>\n            </div>\n          } @else {\n            <!-- Actual content - just the form, no tabs -->\n            <mt-dynamic-form\n              [formConfig]=\"nodeForm()\"\n              [formControl]=\"nodeFormControl\"\n            ></mt-dynamic-form>\n          }\n        </div>\n      </ng-template>\n    </mt-structure-builder>\n  }\n</mt-card>\n", dependencies: [{ kind: "component", type: StructureBuilder, selector: "mt-structure-builder", inputs: ["availableNodes", "nodeForm", "connectionForm", "nodeActions", "nodeFields", "isAutoLayout", "addModalType", "updateModalType", "addModalStyleClass", "updateModalStyleClass", "addModalHeader", "updateModalHeader", "appendTo", "nodes", "connections"], outputs: ["nodeActionsEvent", "action", "nodesChange", "connectionsChange"] }, { kind: "component", type: Card, selector: "mt-card", inputs: ["class", "title", "paddingless"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: DynamicForm, selector: "mt-dynamic-form", inputs: ["formConfig"] }, { kind: "component", type: Skeleton, selector: "p-skeleton", inputs: ["styleClass", "shape", "animation", "borderRadius", "size", "width", "height"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: EscalationBuilder, decorators: [{
+            type: Component,
+            args: [{ selector: 'mt-escalation-builder', imports: [StructureBuilder, Card, ReactiveFormsModule, DynamicForm, Skeleton], host: {}, template: "<mt-card class=\"h-[calc(100vh---spacing(26))] relative\" id=\"escalationCard\">\n  @if (!loading()) {\n    <mt-structure-builder\n      class=\"flex-1\"\n      [availableNodes]=\"availableNodes\"\n      [connectionForm]=\"connectionForm()\"\n      [nodeActions]=\"nodeActions()\"\n      (nodeActionsEvent)=\"onNodeActionsEvent($event)\"\n      [nodes]=\"steps()\"\n      [connections]=\"connections()\"\n      (action)=\"onStructureAction($event)\"\n      [addModalType]=\"'drawer'\"\n      [addModalStyleClass]=\"'!w-[25rem] !absolute !shadow-none'\"\n      [updateModalStyleClass]=\"'!w-[25rem] !absolute !shadow-none'\"\n      [addModalHeader]=\"'Add Step'\"\n      [updateModalHeader]=\"'Edit Step'\"\n      [appendTo]=\"'escalationCard'\"\n      [nodeFields]=\"nodeFields()\"\n    >\n      <ng-template\n        #nodeDialog\n        let-close=\"close\"\n        let-save=\"save\"\n        let-node=\"node\"\n      >\n        <div class=\"p-4\">\n          @if (loadingStep()) {\n            <!-- Loading skeleton -->\n            <div class=\"space-y-4\">\n              <!-- Form fields skeleton -->\n              <div class=\"space-y-4\">\n                <div>\n                  <p-skeleton\n                    width=\"8rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"8rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"10rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"3rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"6rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n                <div>\n                  <p-skeleton\n                    width=\"4rem\"\n                    height=\"1rem\"\n                    styleClass=\"mb-2\"\n                  ></p-skeleton>\n                  <p-skeleton\n                    width=\"100%\"\n                    height=\"2.5rem\"\n                    borderRadius=\"0.5rem\"\n                  ></p-skeleton>\n                </div>\n              </div>\n            </div>\n          } @else {\n            <!-- Actual content - just the form, no tabs -->\n            <mt-dynamic-form\n              [formConfig]=\"nodeForm()\"\n              [formControl]=\"nodeFormControl\"\n            ></mt-dynamic-form>\n          }\n        </div>\n      </ng-template>\n    </mt-structure-builder>\n  }\n</mt-card>\n" }]
+        }], ctorParameters: () => [] });
+
+const ESCALATION_STATES = [EscalationState];
+
+// Re-export app state
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CreateConnection, CreateStep, DeleteConnection, DeleteStep, ESCALATION_STATES, EscalationBuilder, EscalationFacade, EscalationState, GetEscalation, GetFormulaProperties, GetGroups, GetRolesForModule, GetStep, PublishEscalation, SetModuleInfo, UpdateConnection, UpdateStep, ValidateFlow };
+//# sourceMappingURL=masterteam-escalation.mjs.map