@qbs-origin/origin-form 0.5.0

package/esm2022/lib/origin-form.component.mjs

@@ -0,0 +1,2391 @@
+import { Component, EventEmitter, Input, Output, ViewChildren, } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { FormlyField, } from '@ngx-formly/core';
+import { Subject, firstValueFrom, startWith, pairwise, debounceTime, switchMap, catchError, of, takeUntil, map, Subscription, } from 'rxjs';
+import { LabelKeys } from './enums/label.keys';
+import { FluxType, DimensionType, StepControlType, ManualInputControlType, } from './models/forms.model';
+import { EnvironmentType } from './others/environment-type';
+import { Utils } from './others/utils';
+import { ModelPopulationHelper } from './model-population.helper';
+import { FormCssHelper } from './form-css.helper';
+import { PresentationControlType } from './models/flux.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/dictionary.service";
+import * as i2 from "./services/proxy.service";
+import * as i3 from "./services/labels.service";
+import * as i4 from "./services/applicationData.service";
+import * as i5 from "./services/language.service";
+import * as i6 from "./origin-form-auth.service";
+import * as i7 from "./services/forms.service";
+import * as i8 from "./others/config-service";
+import * as i9 from "./services/translation.service";
+import * as i10 from "./services/origin-form-signalr-handler.service";
+import * as i11 from "./action-step-handler";
+import * as i12 from "./services/scroll-to-error.service";
+import * as i13 from "@angular/common";
+import * as i14 from "@angular/forms";
+import * as i15 from "@angular/material/menu";
+import * as i16 from "@angular/material/button";
+import * as i17 from "@angular/material/progress-spinner";
+import * as i18 from "@ngx-formly/core";
+export class CollectorFormComponent {
+    constructor(service, cdRef, renderer, proxy, labelService, applicationDataService, langService, authService, formsService, configService, translationService, originFormSignalrHandlerService, actionStepHandler, scrollToErrorService) {
+        this.service = service;
+        this.cdRef = cdRef;
+        this.renderer = renderer;
+        this.labelService = labelService;
+        this.applicationDataService = applicationDataService;
+        this.langService = langService;
+        this.authService = authService;
+        this.formsService = formsService;
+        this.configService = configService;
+        this.translationService = translationService;
+        this.originFormSignalrHandlerService = originFormSignalrHandlerService;
+        this.actionStepHandler = actionStepHandler;
+        this.scrollToErrorService = scrollToErrorService;
+        this.showDisplayMode = false;
+        this.showLanguageSelector = true;
+        this.isDemoMode = false;
+        this.isDebug = false;
+        this.noButtonsInView = false;
+        this.formlyConfigUpdated = new EventEmitter();
+        this.visibleFieldsUpdated = new EventEmitter();
+        this.formlyUpdateAndGoNext = new EventEmitter();
+        this.formlyGoNext = new EventEmitter();
+        this.completionEvent = new EventEmitter();
+        this.form = new FormGroup({});
+        this.formlyConfig = [];
+        this.formlyAllSteps = [];
+        this.activeStep = 0;
+        this.options = {};
+        this.isLoading = true;
+        this.dictionaryMap = new Map();
+        this.dictionaryIdToUuidMap = new Map();
+        this.generalDataKeys = LabelKeys.appConfigEdit.generalData;
+        this.fieldUnsubscribeSubjects = [];
+        this.collectorHandlerSubscriptions = new Subscription();
+        // Action step execution state
+        this.isExecutingActions = false;
+        this.actionStepSubscriptions = new Subscription();
+        this.isSavingAfterActions = false; // Make this public so stepper can access it
+        this.kycPhoneNumber = '';
+        this.kycLangIso = '';
+        this.kycShowCitizenship = false;
+        this.kycScrollMode = false;
+        // end identification kyc component
+        this.languageFlags = [
+            {
+                language: 'English',
+                code: 'en',
+                type: 'US',
+                icon: '/assets/images/flag/icon-flag-en.svg',
+            },
+            {
+                language: 'Romana',
+                code: 'ro',
+                icon: '/assets/images/flag/icon-flag-ro.svg',
+            },
+            {
+                language: 'Deutsch',
+                code: 'de',
+                icon: '/assets/images/flag/icon-flag-de.svg',
+            },
+            {
+                language: 'Français',
+                code: 'fr',
+                icon: '/assets/images/flag/icon-flag-fr.svg',
+            },
+            {
+                language: 'Italiano',
+                code: 'it',
+                icon: '/assets/images/flag/icon-flag-it.svg',
+            },
+            {
+                language: 'Español',
+                code: 'es',
+                icon: '/assets/images/flag/icon-flag-es.svg',
+            },
+        ];
+        this._self = this;
+        this.loadingMessage = null;
+        this.kycApiUrl = proxy.apiURL;
+        this.kycOrderId = proxy.orderID;
+        this.kycToken = proxy.token;
+        this.kycEnv = proxy.env;
+        this.kycLangIso = proxy.langIso;
+        const isLoadingSub = this.originFormSignalrHandlerService.isLoading$.subscribe((loading) => {
+            if (this.isLoading !== loading) {
+                this.isLoading = loading;
+            }
+        });
+        this.collectorHandlerSubscriptions.add(isLoadingSub);
+        const operationCompletedSub = this.originFormSignalrHandlerService.operationCompleted$.subscribe(async (result) => {
+            if (result.operationIdentifier === 'KYC_PROCESSING') {
+                if (result.success) {
+                    console.log('KYC Processing successfully completed (via Handler Service):', result.data);
+                    if (result.data) {
+                        this.fillData = JSON.parse(result.data.fillData);
+                        this.populateModelWithFillData(this.fillData);
+                    }
+                    this.formlyUpdateAndGoNext.emit({});
+                }
+                else {
+                    console.error('KYC Processing failed (via Handler Service):', result.error);
+                }
+            }
+        });
+        this.collectorHandlerSubscriptions.add(operationCompletedSub);
+        // Subscribe to action step execution events
+        const actionExecutingSub = this.actionStepHandler.actionExecuting$.subscribe((executing) => {
+            this.isExecutingActions = executing;
+            this.isLoading = executing;
+            this.cdRef.detectChanges();
+        });
+        this.actionStepSubscriptions.add(actionExecutingSub);
+        const actionCompletedSub = this.actionStepHandler.actionCompleted$.subscribe((result) => {
+            console.log('🎬 Action step completed:', result);
+            if (!result.success) {
+                console.error('❌ Action step failed:', result.error);
+            }
+            // Note: We don't auto-progress here as it's handled in executeActionStepsBeforeMoving
+        });
+        this.actionStepSubscriptions.add(actionCompletedSub);
+    }
+    async ngOnInit() {
+        if (this.dataUrlId) {
+            var result = await firstValueFrom(this.applicationDataService.getDataUrl(this.dataUrlId));
+            if (result) {
+                this.configUuid = result.appId;
+                this.appDataUuid = result.appDataId;
+                this.env = result.env;
+            }
+        }
+        if (this.appDataUuid && this.currentStepId) {
+            this.applicationDataService.setCurrentStep(this.appDataUuid, this.currentStepId);
+        }
+        if (!this.appDataUuid) {
+            this.appDataUuid = Utils.generateUUID();
+        }
+        if (this.configComponent &&
+            this.configComponent.Token &&
+            this.configComponent.RefreshToken) {
+            this.configService.updateConfigFromInput(this.configComponent);
+            await this.authService.setTokens(this.configComponent.Token, this.configComponent.RefreshToken);
+        }
+        if (!this.availableLanguages || this.availableLanguages.length === 0) {
+            await firstValueFrom(this.langService.getLanguages()).then((list) => {
+                if (list && list.items?.length > 0) {
+                    this.availableLanguages = list.items;
+                }
+            });
+        }
+        await this.loadAppData();
+        if (!this.currentLanguageIso && this.appModel) {
+            this.currentLanguageIso = this.appModel.generalData.defaultLanguage;
+        }
+        if (this.appModel) {
+            await this.initAsync();
+        }
+    }
+    async ngOnChanges(changes) {
+        if (changes['configComponent'] && !changes['configComponent'].firstChange) {
+            if (this.configComponent &&
+                this.configComponent.Token &&
+                this.configComponent.RefreshToken) {
+                this.configService.updateConfigFromInput(this.configComponent);
+                await this.authService.setTokens(this.configComponent.Token, this.configComponent.RefreshToken);
+            }
+        }
+        if (changes['currentLanguageIso'] &&
+            !changes['currentLanguageIso'].firstChange) {
+            this.isLoading = true;
+            try {
+                if (!this.availableLanguages) {
+                    await firstValueFrom(this.langService.getLanguages()).then((list) => {
+                        if (list && list.items?.length > 0) {
+                            this.availableLanguages = list.items;
+                        }
+                    });
+                }
+                if (this.appDataUuid) {
+                    try {
+                        const appData = await this.applicationDataService.getSteps(this.appDataUuid);
+                        if (appData && appData.fillData) {
+                            this.fillData = JSON.parse(appData.fillData);
+                            this.blockPreviousStep = appData.blockPreviousStep;
+                            if (this.fillData.metadata.language) {
+                                this.currentLanguageIso = this.fillData.metadata.language;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error retrieving app data', error);
+                    }
+                }
+                await this.initAsync();
+            }
+            catch (error) {
+            }
+            finally {
+                this.isLoading = false;
+            }
+        }
+    }
+    async loadAppData() {
+        this.isLoading = true;
+        try {
+            const response = await firstValueFrom(this.formsService.loadFormByUuid(this.configUuid, this.env));
+            this.appModel = JSON.parse(response.configuration);
+            this.fillData = response.fillData ? JSON.parse(response.fillData) : null;
+        }
+        catch (error) {
+            console.error('Error loading form data', error);
+        }
+        finally {
+            this.isLoading = false;
+        }
+    }
+    async initAsync() {
+        this.unsubscribeFromAllFields();
+        await this.buildFormlyAsync();
+        await this.initializeReferenceFields(this.formlyConfig);
+        this.updateFormlyConfig();
+        this.formlyConfigUpdated.emit();
+        this.cdRef.detectChanges();
+    }
+    applicationLanguages() {
+        return this.availableLanguages?.filter((a) => {
+            return this.appModel?.generalData?.languages?.indexOf(a.iso) >= 0;
+        });
+    }
+    returnFLag(language) {
+        return this.languageFlags.find((l) => l.code == language)?.icon;
+    }
+    changeLanguage($event) {
+        this.currentLanguageIso = $event;
+        this.applicationDataService
+            .changeLanguage(this.appDataUuid, this.currentLanguageIso)
+            .subscribe();
+        this.initAsync();
+    }
+    getLanguageName(languageIso) {
+        const language = this.availableLanguages.find((lang) => lang.iso === languageIso);
+        return language ? language.name : '';
+    }
+    async buildFormlyAsync() {
+        if (this.currentLanguageIso) {
+            await this.getLabels();
+        }
+        // STEP 1: Initialize flux and other properties first
+        this.flux = this.appModel.flux;
+        this.display = this.appModel.display;
+        this.design = this.appModel.generatedCss;
+        this.generalData = this.appModel.generalData;
+        this.addRenderedCss();
+        // STEP 2: Load ALL dictionaries upfront (now that flux is initialized)
+        await this.loadAllRequiredDictionaries();
+        // STEP 3: Continue with existing form building logic
+        this.formlyConfig = [];
+        this.formlyCollectingFields = [];
+        this.formlyPresentationFields = [];
+        this.model = {};
+        this.form = new FormGroup({});
+        if (this.fillData) {
+            this.populateControlIdsWithValueDictionary();
+        }
+        // Initialize model with default values if no fillData
+        if (!this.fillData) {
+            this.model = ModelPopulationHelper.applyDefaultsToModel(this.flux, this.dictionaryMap, this.availableLanguages);
+        }
+        else {
+            this.populateModelWithFillData(this.fillData);
+            this.populateControlIdsWithValueDictionary();
+        }
+        this.form.patchValue(this.model);
+        await this.buildFormlyConfigAsync();
+        // Initialize references for default values
+        if (!this.fillData) {
+            await this.initializeReferenceFields(this.formlyConfig);
+        }
+        this.form.valueChanges
+            .pipe(startWith(null), pairwise())
+            .subscribe(([prev, next]) => this.handleFormValueChange([prev, next]));
+    }
+    handleFormValueChange([prev, next]) {
+        const currentLanguageId = Utils.findLanguageIdByIso(this.availableLanguages, this.currentLanguageIso);
+        for (const key in next) {
+            if (next[key]?.valueTranslations) {
+                var s = JSON.stringify(next[key]);
+                var replaced = s.replace(/"valueTranslations":/g, '"translations":');
+                next[key] = JSON.parse(replaced);
+            }
+            const fields = this.formlyPresentationFields.filter((i) => i.props && i.props['collectionControlIdentifier'] === key);
+            if (fields && fields.length > 0) {
+                fields.forEach((field) => {
+                    let value = '';
+                    switch (typeof next[key]) {
+                        case 'boolean':
+                            value = next[key] ? '✓' : '✗';
+                            break;
+                        default:
+                            if (next[key]?.translations) {
+                                const translation = next[key].translations.find((translation) => translation.languageId === currentLanguageId);
+                                value = translation ? translation.value : null;
+                            }
+                            else {
+                                value = next[key];
+                            }
+                            break;
+                    }
+                    field.defaultValue = value;
+                });
+            }
+            if (this.stepDictionaryDependentIds.find((a) => a == key)) {
+                if (next[key]?.id &&
+                    (prev == null || prev[key]?.id !== next[key]?.id)) {
+                    this.formlyConfig[0].fieldGroup = this.getFormlyFilteredSteps();
+                    var filteredStepsIdentifiers = this.formlyConfig[0].fieldGroup.map((f) => f.props?.['stepId']);
+                    const visibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux, filteredStepsIdentifiers);
+                    this.updateFormlyConfig();
+                    this.visibleFieldsUpdated.emit(visibleSteps);
+                    this.formlyConfigUpdated.emit();
+                }
+            }
+        }
+    }
+    getLabels() {
+        return new Promise((resolve) => {
+            this.labelService
+                .getLabels(this.currentLanguageIso, false)
+                .subscribe((l) => {
+                this.labels = l;
+                resolve();
+            });
+        });
+    }
+    populateControlIdsWithValueDictionary() {
+        var currentLanguageId = this.getCurrentLanguageId();
+        const controlIdsWithValues = this.fillData.flux
+            .flatMap((step) => step.sections.flatMap((section) => section.controls
+            .filter((control) => control.controlId && control.fillValue)
+            .map((control) => ({
+            controlId: control.controlId,
+            fillValue: control.fillValue,
+            fillValueId: control.fillValueId,
+        }))))
+            .reduce((dictionary, { controlId, fillValue, fillValueId }) => {
+            if (fillValueId) {
+                for (const [key, dict] of this.dictionaryMap.entries()) {
+                    const value = dict.values?.find((v) => v.id == fillValueId);
+                    if (value) {
+                        const translation = value.valueTranslations.find((t) => t.languageId == currentLanguageId);
+                        if (translation) {
+                            dictionary[controlId] = translation.value;
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                dictionary[controlId] = fillValue;
+            }
+            return dictionary;
+        }, {});
+        this.controlIdsWithValues = controlIdsWithValues;
+    }
+    getCurrentLanguageId() {
+        const currentLanguageId = Utils.findLanguageIdByIso(this.availableLanguages, this.currentLanguageIso);
+        return currentLanguageId;
+    }
+    async buildFormlyConfigAsync() {
+        this.stepsSettings = {
+            showCounter: this.showDisplayMode
+                ? false
+                : this.generalData.showCounterStep,
+            showLabels: this.showDisplayMode ? false : this.generalData.showNameStep,
+            showAllSteps: this.showDisplayMode
+                ? false
+                : this.generalData.showAllSteps,
+            showProgressBar: this.generalData.showProgressBar &&
+                this.generalData.showAllSteps == false
+                ? true
+                : false,
+        };
+        this.formlyAllSteps = await this.buildFormlyFieldGroupAsync();
+        var hasDictionaryDependentSteps = this.formlyAllSteps.some((f) => f.props?.['dependentDictionary']?.isDictionaryDependent);
+        var formlyFilteredSteps = this.getFormlyFilteredSteps();
+        var filteredStepsIdentifiers = formlyFilteredSteps.map((f) => f.props?.['stepId']);
+        // Get visible steps for accurate step counting
+        const visibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux);
+        const filteredVisibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux, filteredStepsIdentifiers);
+        this.formlyConfig = [
+            {
+                type: 'stepper',
+                props: {
+                    appDataId: this.fillData
+                        ? this.fillData?.metadata?.appDataId
+                        : this.appDataUuid,
+                    design: this.design,
+                    applicationId: this.appModel.applicationUuid,
+                    flux: visibleSteps, // Pass only visible steps to stepper
+                    filteredFlux: filteredVisibleSteps,
+                    isDisplayMode: this.showDisplayMode,
+                    fillData: this.fillData,
+                    defaultLanguage: this.appModel.generalData.defaultLanguage,
+                    display: this.display,
+                    designConfig: {
+                        buttonsVerticalPosition: this.appModel.design.buttonsVerticalPosition,
+                        buttonsHorizontalPosition: this.appModel.design.buttonsHorizontalPosition,
+                    },
+                    stepsSettings: this.stepsSettings,
+                    metaData: this.fillData?.metadata,
+                    demoMode: this.isDemoMode,
+                    isDebug: this.isDebug,
+                    noButtonsInView: this.noButtonsInView,
+                    blockPreviousStep: this.blockPreviousStep,
+                    env: this.env,
+                    hasDictionaryDependentSteps: hasDictionaryDependentSteps,
+                    hasActionSteps: this.flux.some((step) => this.actionStepHandler.isActionStep(step)), // Indicate if there are action steps
+                    completionEvent: () => this.onCompletion(),
+                    onSelectedPageChanging: (index) => this.onSelectedPageChanging(index),
+                    onSelectedPageChanged: (index) => this.onSelectedPageChanged(index),
+                },
+                fieldGroup: formlyFilteredSteps,
+            },
+        ];
+    }
+    async onSelectedPageChanging(stepTransition) {
+        let fromIndex;
+        let toIndex;
+        let callback = () => { };
+        if (typeof stepTransition === 'number') {
+            toIndex = stepTransition;
+            fromIndex = this.activeStep;
+        }
+        else {
+            fromIndex = stepTransition.from;
+            toIndex = stepTransition.to;
+            callback = stepTransition.callback || (() => { });
+        }
+        let actionsExecuted = false;
+        if (toIndex > fromIndex) {
+            console.log('➡️ Moving forward - executing action steps after current step');
+            actionsExecuted = await this.executeActionStepsAfterCurrentStep(fromIndex);
+        }
+        else if (toIndex < fromIndex) {
+            console.log('⬅️ Moving backward - no action execution needed');
+        }
+        else {
+            console.log('🔄 Staying on same step - no action execution needed');
+        }
+        this.activeStep = toIndex;
+        if (callback) {
+            callback();
+        }
+        return actionsExecuted;
+    }
+    async executeActionStepsAfterCurrentStep(currentStepIndex) {
+        if (this.actionStepHandler.isExecutingActions) {
+            return false;
+        }
+        let filteredSteps = this.flux.filter((s) => {
+            if (s.dependentDictionary &&
+                s.dependentDictionary.isDictionaryDependent) {
+                const selectedValue = this.model[s.dependentDictionary.dictionaryControlIdentifier]?.id;
+                if (selectedValue &&
+                    s.dependentDictionary.dependentValueIds.includes(selectedValue)) {
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        });
+        const actionSteps = this.actionStepHandler.getActionStepsAtIndex(filteredSteps, currentStepIndex);
+        if (actionSteps.length === 0) {
+            return false;
+        }
+        try {
+            if (!this.appDataUuid) {
+                return false;
+            }
+            // Set the saving flag before starting actions
+            this.isSavingAfterActions = true;
+            this.isLoading = true;
+            const result = await this.actionStepHandler.executeActionSteps(actionSteps, this.appDataUuid, (step) => {
+                const loadingMessage = Utils.findTranslationInfo('loadingMessageTranslations', step.translations, this.currentLanguageIso);
+                this.loadingMessage = loadingMessage || null;
+            });
+            if (result.success) {
+                console.log('✅ Action steps executed successfully');
+                // Keep loading state true - it will be cleared after saveAppDataStep completes
+                return true;
+            }
+            else {
+                console.error('❌ Action steps execution failed:', result.error);
+                this.isSavingAfterActions = false;
+                this.isLoading = false;
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ Error executing action steps:', error);
+            this.isSavingAfterActions = false;
+            this.isLoading = false;
+            return false;
+        }
+    }
+    onSelectedPageChanged(index) {
+        if (this.formlyConfig[0].fieldGroup) {
+            var selectedPage = this.formlyConfig[0].fieldGroup[index];
+            this.setPresentationControlValuesRecursively(selectedPage);
+        }
+    }
+    setPresentationControlValuesRecursively(fc) {
+        fc?.fieldGroup?.forEach((fg) => {
+            if (fg.props && fg.props['isDisplayMode'] === true) {
+                var methodFieldId = fg.props['apiMethodFieldId'];
+                if (methodFieldId) {
+                    const val = this.findInApiCallsResponses(methodFieldId);
+                    fg.defaultValue = val;
+                }
+                else {
+                    var associatedControlId = fg.props['collectionControlIdentifier'];
+                    if (associatedControlId) {
+                        const found = this.findControlInFillDataControls(associatedControlId);
+                        if (found) {
+                            if (found.fillValueId) {
+                                const currentLanguageId = this.getCurrentLanguageId();
+                                for (const [key, dict] of this.dictionaryMap.entries()) {
+                                    const value = dict.values?.find((v) => v.id == found.fillValueId);
+                                    if (value) {
+                                        const translation = value.valueTranslations.find((t) => t.languageId == currentLanguageId);
+                                        if (translation) {
+                                            fg.defaultValue = translation.value;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                fg.defaultValue = found.fillValue;
+                            }
+                        }
+                        else {
+                            const val = this.findInApiCallsResponses(associatedControlId);
+                            fg.defaultValue = val;
+                        }
+                    }
+                }
+            }
+            else {
+                this.setPresentationControlValuesRecursively(fg);
+            }
+            if (fg.props['cdr']) {
+                fg.props['cdr'].detectChanges();
+            }
+        });
+    }
+    findControlInFillDataControls(controlId) {
+        let controlData = undefined;
+        if (this.fillData) {
+            this.fillData.flux?.forEach((f) => {
+                if (!controlData) {
+                    f.sections?.forEach((s) => {
+                        if (!controlData) {
+                            controlData = s.controls?.find((c) => c.controlId === controlId);
+                            if (controlData) {
+                                return controlData;
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        return controlData;
+    }
+    findInApiCallsResponses(fieldId) {
+        let foundValue = undefined;
+        if (this.fillData) {
+            this.fillData.APICalls?.forEach((api) => {
+                if (!foundValue) {
+                    api.Methods?.forEach((m) => {
+                        if (!foundValue) {
+                            const found = m.Fields?.[fieldId];
+                            if (found) {
+                                foundValue = found;
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        return foundValue;
+    }
+    getFormlyFilteredSteps() {
+        let steps = this.formlyAllSteps.filter((s) => {
+            if (s.props && s.props['dependentDictionary']) {
+                const depDict = s.props['dependentDictionary'];
+                if (depDict && depDict.isDictionaryDependent) {
+                    const selectedValue = this.model[depDict.dictionaryControlIdentifier]?.id;
+                    if (selectedValue &&
+                        depDict.dependentValueIds.includes(selectedValue)) {
+                        return true;
+                    }
+                    return false;
+                }
+            }
+            return true;
+        });
+        return steps;
+    }
+    async buildFormlyFieldGroupAsync() {
+        this.stepDictionaryDependentIds = [];
+        if (this.showDisplayMode) {
+            const step = await this.buidDisplayStep();
+            return Promise.resolve([step]);
+        }
+        else {
+            // Filter out action steps from visible steps
+            const visibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux);
+            return await Promise.all(visibleSteps.map((step) => {
+                return this.buildFormlyFieldConfigAsync(step);
+            }) ?? []);
+        }
+    }
+    async buildFormlyFieldConfigAsync(step) {
+        let stepFormlyConfig = {};
+        if (step.type !== FluxType.Custom && step.type !== FluxType.Final) {
+            stepFormlyConfig = await this.buildSystemFieldFormlyConfig(step);
+        }
+        else {
+            stepFormlyConfig = {
+                props: {
+                    label: step.name,
+                    description: step.name,
+                    buttons: this.constructButtons(step.buttons),
+                    dependentDictionary: step.dependentDictionary,
+                    stepId: step.identifier,
+                },
+                fieldGroup: await this.buildSectionsFieldGroupAsync(step, step.sections),
+            };
+            if (step.translations) {
+                stepFormlyConfig.props['label'] = Utils.findTranslationInfo('name', step.translations, this.currentLanguageIso);
+                stepFormlyConfig.props['description'] = Utils.findTranslationInfo('description', step.translations, this.currentLanguageIso);
+            }
+        }
+        if (stepFormlyConfig && stepFormlyConfig.props) {
+            this.setStepBaseProps(step, stepFormlyConfig);
+        }
+        if (step.dependentDictionary?.isDictionaryDependent) {
+            this.stepDictionaryDependentIds.push(step.dependentDictionary.dictionaryControlIdentifier);
+        }
+        return stepFormlyConfig;
+    }
+    triggerComponentUpdate(controlId, value) {
+        this.setFormlyFieldValue(this.formlyAllSteps, controlId, value);
+    }
+    setFormlyFieldValue(fields, key, value) {
+        if (!fields)
+            return false;
+        for (const field of fields) {
+            if (field.key === key) {
+                if (field.formControl) {
+                    field.formControl.setValue(value, { emitEvent: true });
+                    return true;
+                }
+            }
+            if (field.fieldGroup && Array.isArray(field.fieldGroup)) {
+                const found = this.setFormlyFieldValue(field.fieldGroup, key, value);
+                if (found)
+                    return true;
+            }
+        }
+        return false;
+    }
+    async buildSystemFieldFormlyConfig(step) {
+        const formlyConfig = {
+            props: {
+                label: step.name,
+                buttons: this.constructButtons(step.buttons),
+                fluxType: step.type,
+            },
+            fieldGroup: [],
+        };
+        this.setStepBaseProps(step, formlyConfig);
+        var fieldConfig = this.createFormlySystemFieldConfig(step);
+        if (fieldConfig) {
+            if (step.translations) {
+                let labels = {};
+                step.translations.forEach((tr) => {
+                    labels[tr.name] = Utils.findTranslation(tr.values, this.currentLanguageIso);
+                });
+                fieldConfig.props['labels'] = labels;
+                fieldConfig.props['name'] = Utils.findTranslationInfo('name', step.translations, this.currentLanguageIso);
+                fieldConfig.props['description'] = Utils.findTranslationInfo('description', step.translations, this.currentLanguageIso);
+                formlyConfig.props['label'] = Utils.findTranslationInfo('name', step.translations, this.currentLanguageIso);
+                formlyConfig.props['description'] = Utils.findTranslationInfo('description', step.translations, this.currentLanguageIso);
+            }
+            fieldConfig.props['stepsSettings'] = this.stepsSettings;
+            formlyConfig.fieldGroup.push(fieldConfig);
+        }
+        return formlyConfig;
+    }
+    setStepBaseProps(step, formlyConfig) {
+        if (formlyConfig.props) {
+            formlyConfig.props['name'] = step.name;
+            formlyConfig.props['fluxType'] = step.type;
+            formlyConfig.props['stepId'] = step.identifier;
+            formlyConfig.props['isVisible'] = step.isVisible;
+            formlyConfig.props['dependentDictionary'] = step.dependentDictionary;
+        }
+    }
+    CreateSignFieldConfig(step) {
+        return {
+            type: 'formly-sign-component',
+            props: {
+                appDataId: this.appDataUuid,
+                stepData: step,
+                design: this.design,
+                env: this.env,
+                flux: this.flux,
+                parentForm: this.form,
+                getModel: () => this.model,
+                event: async (event) => {
+                    if (event === 'success') {
+                        await this.stepperGoNextAsync();
+                    }
+                },
+            },
+        };
+    }
+    CreateDownloadDocsFieldConfig(controlData) {
+        return {
+            type: 'formly-download-documents-component',
+            props: {
+                appId: this.appModel.applicationUuid,
+                appDataId: this.appDataUuid,
+                controlData: controlData,
+                env: this.env,
+                documentsData: this.appModel.documents,
+                langIso: this.currentLanguageIso,
+            },
+        };
+    }
+    CreateViewDocsFieldConfig(controlData) {
+        return {
+            type: 'formly-view-documents-component',
+            props: {
+                appId: this.appModel.applicationUuid,
+                appDataId: this.appDataUuid,
+                controlData: controlData,
+                env: this.env,
+                documentsData: this.appModel.documents,
+                langIso: this.currentLanguageIso,
+            },
+        };
+    }
+    CreateUploadDocsFieldConfig(controlData) {
+        return {
+            type: 'formly-upload-documents-component',
+            props: {
+                appId: this.appModel.applicationUuid,
+                appDataId: this.appDataUuid,
+                controlData: controlData,
+                env: this.env,
+                documentsData: this.appModel.documents,
+                langIso: this.currentLanguageIso,
+            },
+        };
+    }
+    CreateGenerateDocsFieldConfig(step) {
+        return {
+            type: 'formly-generate-documents-component',
+            props: {
+                appId: this.appModel.applicationUuid,
+                appDataId: this.appDataUuid,
+                stepData: step,
+                documentsData: this.appModel.documents,
+                langIso: this.currentLanguageIso,
+                event: async (event) => {
+                    if (event === 'success') {
+                        await this.stepperGoNextAsync();
+                    }
+                },
+            },
+        };
+    }
+    async stepperGoNextAsync() {
+        const stepperComponent = this.formlyConfig[0].props['component'];
+        if (stepperComponent && stepperComponent.navigateNextAsync) {
+            await stepperComponent.navigateNextAsync();
+        }
+    }
+    CreateEnrollCardFieldConfig(step) {
+        let labels = {};
+        Object.keys(step.config).forEach((key) => {
+            if (key.endsWith('Label')) {
+                labels[key] =
+                    step?.config[key]?.find((i) => i.languageIso === this.currentLanguageIso)?.value ?? '';
+            }
+        });
+        return {
+            type: 'formly-enrol-card-component',
+            props: {
+                appId: this.appModel.applicationUuid,
+                appDataId: this.appDataUuid,
+                dataUrlId: this.dataUrlId,
+                stepData: step,
+                labels: labels,
+                langIso: this.currentLanguageIso,
+            },
+        };
+    }
+    CreateIdScanFieldConfig(step) {
+        let errorMessages = {};
+        if (step.errorsTranslations) {
+            step.errorsTranslations.forEach((error) => {
+                errorMessages[error.code] = Utils.findTranslation(error.translations, this.currentLanguageIso);
+            });
+        }
+        return {
+            type: 'formly-scan-id',
+            props: {
+                config: step.config,
+                stepType: step.type,
+                stepId: step.identifier,
+                appDataId: this.appDataUuid || Utils.generateUUID(),
+                appId: this.appModel.applicationUuid,
+                errorMessages: errorMessages,
+                event: (event) => this.onIdScanCompleted(event, step),
+            },
+        };
+    }
+    CreateKycFieldConfig(step) {
+        const loadingMsgTranslations = step.translations?.find((t) => t.name === 'loadingMessageTranslations');
+        const translatedLoadingMessage = loadingMsgTranslations?.values?.find((v) => v.languageIso === this.currentLanguageIso)?.value || '';
+        return {
+            type: 'formly-identification-component',
+            props: {
+                token: this.kycToken,
+                api_url: this.kycApiUrl,
+                appDataId: this.appDataUuid,
+                env: 'QA', // Consider making this dynamic if needed
+                redirect_id: this.kycRedirectId,
+                phone_number: '',
+                lang_iso: this.kycLangIso,
+                show_citizenship_selector: this.kycShowCitizenship,
+                scroll_mode: this.kycScrollMode,
+                maxRetries: step.config?.maxKycRetries ?? 3,
+                loadingMessage: translatedLoadingMessage,
+                ectCompleted: async () => {
+                    this.loadingMessage = translatedLoadingMessage;
+                    await this.originFormSignalrHandlerService.initiateKycProcessing(this.appDataUuid);
+                },
+            },
+        };
+    }
+    CreatePhoneEmailFieldConfig(step) {
+        return {
+            type: 'formly-validate-contact-info',
+            props: {
+                stepData: step,
+                appDataId: this.appDataUuid,
+                design: this.design,
+                event: async (event) => {
+                    if (event === 'success') {
+                        await this.stepperGoNextAsync();
+                    }
+                },
+            },
+        };
+    }
+    CreateViewOfferFieldConfig(step) {
+        return {
+            type: 'formly-view-offers',
+            props: {
+                appDataId: this.appDataUuid,
+                stepData: step,
+                env: this.env,
+                appModel: this.appModel,
+                langIso: this.currentLanguageIso,
+                event: (event) => this.onOfferSelected(event, step),
+            },
+        };
+    }
+    CreatePauseFieldConfig(step) {
+        return {
+            type: 'formly-field-pause',
+            props: {
+                identifier: step.identifier,
+                config: step.config,
+                appDataId: this.appDataUuid,
+                stepData: step,
+                env: this.env,
+                appModel: this.appModel,
+                langIso: this.currentLanguageIso,
+            },
+        };
+    }
+    CreateOpenBankingFieldConfig(step) {
+        // Pass the full step data which includes all translations
+        // The component will extract what it needs based on current language
+        return {
+            type: 'formly-open-banking',
+            props: {
+                identifier: step.identifier,
+                config: step.config,
+                appDataId: this.appDataUuid,
+                stepData: step, // This contains the full translations array
+                env: this.env,
+                appModel: this.appModel,
+                langIso: this.currentLanguageIso,
+                labels: {
+                    initialMessage: Utils.findTranslation(step.config?.initialMessageTranslations || [], this.currentLanguageIso),
+                    waitingMessage: Utils.findTranslation(step.config?.waitingMessageTranslations || [], this.currentLanguageIso),
+                    consentErrorMessage: Utils.findTranslation(step.config?.consentErrorMessageTranslations || [], this.currentLanguageIso),
+                    completionMessage: Utils.findTranslation(step.config?.completionMessageTranslations || [], this.currentLanguageIso),
+                    retryButtonLabel: Utils.findTranslation(step.config?.retryButtonLabelTranslations || [], this.currentLanguageIso),
+                },
+                event: (event) => this.onOpenBankingEvent(event, step),
+            },
+        };
+    }
+    CreateStatusFieldConfig(step) {
+        return {
+            type: 'formly-status',
+            props: {
+                config: step.config,
+                stepData: step,
+                appDataId: this.appDataUuid,
+                appId: this.appModel.applicationUuid,
+            },
+        };
+    }
+    createFormlySystemFieldConfig(step) {
+        switch (step.type) {
+            case FluxType.Kyc:
+                {
+                    return this.CreateKycFieldConfig(step);
+                }
+                break;
+            case FluxType.Email:
+            case FluxType.Phone: {
+                return this.CreatePhoneEmailFieldConfig(step);
+            }
+            case FluxType.Action: {
+                // Action steps are now handled automatically by ActionStepHandler
+                // They should not appear as visible formly components
+                return undefined;
+            }
+            case FluxType.IdScan: {
+                return this.CreateIdScanFieldConfig(step);
+            }
+            case FluxType.GenerateDocument: {
+                return this.CreateGenerateDocsFieldConfig(step);
+            }
+            case FluxType.Sign: {
+                return this.CreateSignFieldConfig(step);
+            }
+            case FluxType.ViewOffer: {
+                return this.CreateViewOfferFieldConfig(step);
+            }
+            case FluxType.Status: {
+                return this.CreateStatusFieldConfig(step);
+            }
+            case FluxType.EUPLATESC: {
+                return this.CreateEnrollCardFieldConfig(step);
+            }
+            case FluxType.NETOPIA: {
+                return this.CreateEnrollCardFieldConfig(step);
+            }
+            case FluxType.Pause: {
+                return this.CreatePauseFieldConfig(step);
+            }
+            case FluxType.OpenBanking: {
+                return this.CreateOpenBankingFieldConfig(step);
+            }
+        }
+        return undefined;
+    }
+    onOfferSelected(offerId, step) {
+        this.formlyUpdateAndGoNext.emit({ selectedOfferId: offerId });
+    }
+    onSignEvent(event, step) {
+        console.log('Sign event received:', event);
+        this.updateStepButtonState(step);
+    }
+    onOpenBankingEvent(event, step) {
+        console.log('OpenBanking event received:', event);
+        if (event === 'success') {
+            // Open Banking flow completed successfully
+            this.updateStepButtonState(step);
+            // Auto-proceed to next step
+            this.formlyUpdateAndGoNext.emit({});
+        }
+    }
+    onIdScanCompleted(event, step) {
+        console.log('Sign event received:', event);
+        const fillData = JSON.parse(event.fillData);
+        const stepFillData = fillData.flux.find((s) => s.stepId == step.identifier);
+        stepFillData.sections.forEach((s) => {
+            s.controls.forEach((c) => {
+                if (c.controlId) {
+                    const value = {
+                        [c.controlId]: {
+                            value: c.fillValue,
+                        },
+                    };
+                    if (this.form.contains(c.controlId)) {
+                        this.form.patchValue(value);
+                    }
+                    else {
+                        this.form.addControl(c.controlId, new FormControl(c.fillValue));
+                    }
+                }
+            });
+        });
+        this.updateStepButtonState(step);
+    }
+    updateStepButtonState(step) {
+        let formlyStepField = this.formlyConfig[0].fieldGroup?.find((field) => field.fieldGroup?.find((f) => f.props?.['stepId'] === step.identifier));
+        if (!formlyStepField) {
+            formlyStepField = this.formlyConfig[0].fieldGroup?.find((field) => field.props?.['stepId'] === step.identifier);
+        }
+        if (formlyStepField) {
+            formlyStepField.props = {
+                ...formlyStepField.props,
+                buttonsDisabled: false,
+            };
+            this.updateFormlyConfig();
+            this.formlyConfigUpdated.emit();
+        }
+    }
+    addRenderedCss() {
+        const styleString = FormCssHelper.convertToStyleString(this.design, this.showDisplayMode);
+        const styleElement = this.renderer.createElement('style');
+        styleElement.id = 'rendered-css';
+        const rendEl = document.getElementById('rendered-css');
+        if (rendEl) {
+            this.renderer.removeChild(document.body, rendEl);
+        }
+        this.renderer.appendChild(styleElement, this.renderer.createText(Utils.removeNewLines(styleString)));
+        this.renderer.appendChild(document.body, styleElement);
+    }
+    async buildSectionsFieldGroupAsync(step, sections) {
+        const stepSections = [];
+        for (let index = 0; sections && index < sections.length; index++) {
+            const section = sections[index];
+            let separatorFormlyConfig = {};
+            if (section.showSectionTitle) {
+                separatorFormlyConfig = {
+                    type: 'separator',
+                    props: {
+                        title: section.translations?.find((t) => t.languageIso === this.currentLanguageIso)?.value ?? '',
+                        design: this.design,
+                    },
+                };
+            }
+            if (section.showSectionSeparator) {
+                separatorFormlyConfig = {
+                    ...separatorFormlyConfig,
+                    type: 'separator',
+                    props: {
+                        ...separatorFormlyConfig.props,
+                        showSeparator: section.showSectionSeparator,
+                    },
+                };
+            }
+            if (section.dependentDictionary) {
+                this.attachToDependentDictionaryIfNecessary(section.dependentDictionary, separatorFormlyConfig);
+            }
+            stepSections.push(separatorFormlyConfig);
+            const sectionFormlyConfig = {
+                type: 'custom-section',
+                props: {
+                    label: section.title,
+                    description: section.translations?.find((t) => t.languageIso === this.currentLanguageIso)?.value ?? '',
+                    design: this.design,
+                },
+                fieldGroup: await this.buildControlsFieldGroupAsync(step, section.controls || [], section.presentationControls || []),
+                fieldGroupClassName: 'display-flex',
+            };
+            if (section.dependentDictionary) {
+                this.attachToDependentDictionaryIfNecessary(section.dependentDictionary, sectionFormlyConfig);
+            }
+            stepSections.push(sectionFormlyConfig);
+        }
+        return stepSections;
+    }
+    async buidDisplayStep() {
+        let stepFormlyConfig = {};
+        if (this.display?.sections?.length > 0) {
+            stepFormlyConfig = {
+                props: {
+                // label: step.name,
+                // buttons: this.constructButtons(step.buttons),
+                //  dependentDictionary: step.dependentDictionary,
+                },
+                fieldGroup: await this.buildSectionsFieldGroupAsync(undefined, this.display.sections),
+            };
+        }
+        return stepFormlyConfig;
+    }
+    addNewRowToFormFieldsIfNecessary(fieldGroup, newRow) {
+        if (newRow.fieldGroup && newRow.fieldGroup.length > 0) {
+            this.calculateFormFieldsWidth(newRow.fieldGroup);
+            fieldGroup.push(newRow);
+        }
+    }
+    calculateFormFieldsWidth(formFields) {
+        const colWidthPerItem = 12 / formFields.length;
+        formFields.forEach((f) => {
+            f.className = 'col-' + colWidthPerItem;
+        });
+    }
+    getPercentageClassName(percentageDimension) {
+        const totalColumns = 12; // 12-column grid
+        const span = Math.round((percentageDimension / 100) * totalColumns);
+        const className = `percentage-width-${span}`;
+        if (!document.getElementById(className)) {
+            const style = document.createElement('style');
+            style.type = 'text/css';
+            style.id = className;
+            style.innerHTML = `
+        .${className} {
+          grid-column: span ${span};
+        }
+      `;
+            document.head.appendChild(style);
+        }
+        return className;
+    }
+    createFillerControl(span) {
+        return {
+            type: 'row-filler',
+            className: `percentage-width-${span}`,
+            props: {
+                label: '',
+                disabled: true,
+                hide: true,
+            },
+        };
+    }
+    async buildControlsFieldGroupAsync(step, controls, presentationControls) {
+        const result = [];
+        let rowItems = [];
+        controls = controls.filter((c) => !c.isOnlyForConfig);
+        // Filter out controls that are incomplete
+        controls = controls.filter((c) => {
+            // Skip controls that are missing essential data
+            if (c.type === StepControlType.Dictionary &&
+                !c.specificControlData?.dictionaryUUID)
+                return false;
+            return true;
+        });
+        const processRow = async (items) => {
+            const fields = [];
+            const total = 12;
+            const built = [];
+            const auto = [];
+            let used = 0;
+            for (const i of items) {
+                if ('collectionControlIdentifier' in i === true) {
+                    built.push(await this.buildPresentationFormFieldAsync(step, i));
+                }
+                else if ('apiMethodId' in i === true) {
+                    built.push(await this.buildApiMethodFormFieldAsync(step, i));
+                }
+                else {
+                    built.push(await this.buildFormFieldAsync(step, i));
+                }
+            }
+            for (let i = 0; i < items.length; i++) {
+                const c = items[i];
+                const f = built[i];
+                if (c.dimensionType === DimensionType.Percentage) {
+                    if (c.autoDimension) {
+                        auto.push({ c, f });
+                    }
+                    else {
+                        const s = Math.round((c.dimension / 100) * total);
+                        used += s;
+                        const percentageClass = this.getPercentageClassName(c.dimension);
+                        f.className = `${f.className} ${percentageClass}`;
+                    }
+                }
+                else if (c.dimensionType === DimensionType.Pixels) {
+                    const s = Math.round((c.dimension / window.innerWidth) * total);
+                    used += s;
+                    const percentageClass = this.getPercentageClassName((s / total) * 100);
+                    f.className = `${f.className} ${percentageClass}`;
+                }
+                else if (c.autoDimension) {
+                    auto.push({ c, f });
+                }
+                else {
+                    used += 1;
+                    const percentageClass = this.getPercentageClassName((1 / total) * 100);
+                    f.className = `${f.className} ${percentageClass}`;
+                }
+            }
+            const rem = total - used;
+            if (auto.length > 0) {
+                const share = Math.max(Math.floor(rem / auto.length), 1);
+                for (const a of auto) {
+                    const percentageClass = this.getPercentageClassName((share / total) * 100);
+                    a.f.className = `${a.f.className} ${percentageClass}`;
+                }
+            }
+            fields.push(...built);
+            return fields;
+        };
+        for (const c of [...controls, ...presentationControls]) {
+            if (('type' in c && c.type === StepControlType.NewRow) ||
+                c.type == PresentationControlType.NewRow) {
+                if (rowItems.length > 0) {
+                    result.push(...(await processRow(rowItems)));
+                    rowItems = [];
+                }
+            }
+            else {
+                rowItems.push(c);
+            }
+        }
+        if (rowItems.length > 0) {
+            result.push(...(await processRow(rowItems)));
+        }
+        return result;
+    }
+    getPixelClassName(pixelDimension) {
+        const className = `pixel-width-${pixelDimension}`;
+        if (!document.getElementById(className)) {
+            const style = document.createElement('style');
+            style.type = 'text/css';
+            style.id = className;
+            style.innerHTML = `
+        .${className} {
+          width: ${pixelDimension}px;
+        }
+      `;
+            document.head.appendChild(style);
+        }
+        return className;
+    }
+    async buildFormFieldAsync(step, control) {
+        let initialType = 'input'; // Default type
+        let componentStyleKey = `.component-text-field`; // Default style for text input
+        const baseStyle = this.design[`.font-${initialType}`] || {};
+        const controlStyleString = this.styleObjectToStringExceptBackground(baseStyle);
+        let pattern = '';
+        if (control.specificControlData?.allowedCharacters) {
+            try {
+                pattern = new RegExp(control.specificControlData.allowedCharacters)
+                    .source;
+            }
+            catch (e) {
+                console.error('incorrect regex pattern', e);
+            }
+        }
+        const componentsToExcludeFromStyle = [
+            '.component-text-field',
+            '.component-checkbox',
+            '.component-radio',
+            '.component-date',
+            '.component-data',
+        ];
+        let formlyConfig = this.getDefaultFormlyFieldConfig(control, initialType, pattern, componentStyleKey, componentsToExcludeFromStyle);
+        //control.specificControlData.type === 3  is email
+        if (control.specificControlData?.type === 3) {
+            this.addValidators(formlyConfig, control);
+        }
+        if (control.specificControlData?.isApiValidation) {
+            this.addApiValidators(formlyConfig, control);
+        }
+        switch (control.type) {
+            case StepControlType.ManualInput: // Text
+                var subType = control.specificControlData
+                    ?.type;
+                switch (subType) {
+                    case ManualInputControlType.Numeric:
+                        formlyConfig.type = 'number';
+                        break;
+                    case ManualInputControlType.Email:
+                    case ManualInputControlType.Text:
+                    case ManualInputControlType.Phone:
+                        formlyConfig.type = 'input';
+                        break;
+                    case ManualInputControlType.TextArea:
+                        formlyConfig.type = 'input';
+                        formlyConfig.props['autosize'] = false;
+                        componentStyleKey = '.component-text-field';
+                        break;
+                    case ManualInputControlType.DateTime:
+                        formlyConfig.type = 'datepicker';
+                        formlyConfig.props = {
+                            readonly: true,
+                        };
+                        componentStyleKey = '.component-date';
+                        break;
+                    default:
+                        formlyConfig.type = 'input';
+                        componentStyleKey = '.component-text-field';
+                        break;
+                }
+                break;
+            case StepControlType.Paragraph: // Paragraph
+                formlyConfig.type = 'formly-paragraph';
+                componentStyleKey = '.component-text-field';
+                const translatedDescription = control.specificControlData?.descriptionTranslations?.find((d) => d.languageIso === this.currentLanguageIso)?.value || '';
+                formlyConfig.defaultValue = translatedDescription;
+                break;
+            case StepControlType.CheckBox: // Checkbox
+                formlyConfig.type = 'formly-checkbox';
+                componentStyleKey = '.component-checkbox';
+                var checked = control.specificControlData?.checked ?? false;
+                formlyConfig.props['checked'] = checked;
+                break;
+            case StepControlType.Dictionary: // Dictionary (dropdown)
+                componentStyleKey =
+                    control.specificControlData.showAsRadioButtonsList === true
+                        ? '.component-radio'
+                        : '.component-data';
+                await this.constructDictionary(control, formlyConfig);
+                break;
+            case StepControlType.Buttons:
+                formlyConfig.type = '';
+                break;
+            case StepControlType.FluxInfo:
+                formlyConfig.type = '';
+                break;
+            case StepControlType.DownloadDocuments:
+                formlyConfig = this.CreateDownloadDocsFieldConfig(control);
+                break;
+            case StepControlType.ViewDocuments:
+                formlyConfig = this.CreateViewDocsFieldConfig(control);
+                break;
+            case StepControlType.UploadDocuments:
+                formlyConfig = this.CreateUploadDocsFieldConfig(control);
+                break;
+            case StepControlType.NewRow: // New Row
+                formlyConfig.type = '';
+                break;
+            default:
+                formlyConfig.type = 'input';
+                componentStyleKey = '.component-text-field';
+        }
+        formlyConfig.className = componentStyleKey.substring(1);
+        if (!componentsToExcludeFromStyle.find((c) => c === componentStyleKey)) {
+            if (this.design[componentStyleKey]) {
+                formlyConfig.props.attributes['style'] +=
+                    ';' +
+                        this.styleObjectToStringExceptBackground(this.design[componentStyleKey]);
+            }
+            // Apply label styles
+            const labelStyleKey = `${componentStyleKey}-label`;
+            if (this.design[labelStyleKey]) {
+                formlyConfig.props.attributes['style'] +=
+                    ';' +
+                        this.styleObjectToStringExceptBackground(this.design[componentStyleKey]);
+            }
+        }
+        if (control.dependentDictionary) {
+            this.attachToDependentDictionaryIfNecessary(control.dependentDictionary, formlyConfig);
+        }
+        let translatedTitle = control.translations?.find((d) => d.languageIso === this.currentLanguageIso)?.value;
+        if (!translatedTitle) {
+            translatedTitle = control.title;
+        }
+        formlyConfig.props['label'] = translatedTitle;
+        this.formlyCollectingFields.push(formlyConfig);
+        return formlyConfig;
+    }
+    addValidators(formlyConfig, control) {
+        var emailErrorLabel = this.flux?.find((f) => f?.config?.componentCollected === control?.identifier)?.config?.emailErrorLabel;
+        var emailErrorLabelValue = '';
+        if (emailErrorLabel != null && Array.isArray(emailErrorLabel)) {
+            emailErrorLabelValue =
+                emailErrorLabel.find((l) => l.languageIso === this.currentLanguageIso)?.value ?? '';
+        }
+        formlyConfig.validators = {
+            emailValid: {
+                expression: (cont) => {
+                    const value = cont.value;
+                    const emailPattern = new RegExp('^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$');
+                    if (value && !emailPattern.test(value)) {
+                        cont.setErrors({ invalidEmail: true });
+                        return false;
+                    }
+                    return true;
+                },
+                message: emailErrorLabelValue,
+            },
+        };
+    }
+    addApiValidators(formlyConfig, control) {
+        formlyConfig.asyncValidators = {
+            validateThroughApi: {
+                expression: (cont) => {
+                    return (cont.valueChanges.pipe(debounceTime(500), switchMap(() => {
+                        const apiValidationMethod = control.specificControlData.apiValidationMethod;
+                        const bodyValue = this.appModel.partners
+                            .flatMap((p) => p.partnerSettings.partnerMethodsApi)
+                            .find((p) => p.methodId === apiValidationMethod)
+                            ?.bodyConfiguration.bodyMapFields;
+                        const fieldMap = bodyValue?.reduce((acc, f) => {
+                            if (f.fluxFieldId === control.identifier) {
+                                acc[f.partnerField] = cont.value || '';
+                            }
+                            else {
+                                acc[f.partnerField] = '';
+                            }
+                            return acc;
+                        }, {}) || {};
+                        const dataRequest = {
+                            appId: this.appModel.applicationId,
+                            apiId: apiValidationMethod,
+                            data: JSON.stringify(fieldMap),
+                        };
+                        return this.validateMethodApi(dataRequest).pipe(catchError(() => of(false)));
+                    })) || 'ssssssssssssssss');
+                },
+                message: 'Validation failed.',
+            },
+        };
+    }
+    getDefaultFormlyFieldConfig(control, type, pattern, componentStyleKey, componentsToExcludeFromStyle) {
+        const currentLanguageId = Utils.findLanguageIdByIso(this.availableLanguages, this.currentLanguageIso);
+        let formlyConfig = {
+            key: control.identifier || control.title,
+            type: type,
+            props: {
+                currentLanguageIso: this.currentLanguageIso,
+                currentLanguageId: currentLanguageId,
+                label: control.translations?.find((t) => t.languageIso === this.currentLanguageIso)?.value || '',
+                title: control.translations?.find((t) => t.languageIso === this.currentLanguageIso)?.value || '',
+                design: this.design,
+                required: control.isMandatory,
+                attributes: {
+                    style: componentsToExcludeFromStyle.find((c) => c === componentStyleKey)
+                        ? ''
+                        : componentStyleKey,
+                },
+                autosize: true,
+                options: [{}],
+                fieldGroup: [],
+                autoDimension: control.autoDimension,
+            },
+            expressions: {},
+            hooks: {},
+            validators: {},
+        };
+        formlyConfig.validation = {};
+        if (control.specificControlData?.isMandatory && formlyConfig.props) {
+            var requiredMessage = Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'isMandatoryValidation');
+            formlyConfig.props.required = control.specificControlData?.isMandatory;
+            formlyConfig.validation.messages = {
+                ...formlyConfig.validation?.messages,
+                required: requiredMessage,
+            };
+        }
+        if (control.type === StepControlType.Dictionary &&
+            control.specificControlData?.isMandatory &&
+            control.errorsTranslations &&
+            formlyConfig.props) {
+            var requiredMessage = Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'isMandatory');
+            formlyConfig.props.required = control.specificControlData?.isMandatory;
+            formlyConfig.validation.messages = {
+                ...formlyConfig.validation?.messages,
+                required: requiredMessage,
+            };
+        }
+        let simpleValidationMessage = '';
+        if (control.specificControlData?.isSimpleValidation && formlyConfig.props) {
+            if (control.specificControlData?.isSimpleValidation &&
+                formlyConfig.props) {
+                simpleValidationMessage = Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'simpleValidation');
+                if (control.specificControlData?.minValue?.toString()) {
+                    formlyConfig.props.min = control.specificControlData.minValue;
+                    formlyConfig.validation.messages = {
+                        ...formlyConfig.validation?.messages,
+                        min: simpleValidationMessage,
+                    };
+                }
+                if (control.specificControlData?.maxValue?.toString()) {
+                    formlyConfig.props.max = control.specificControlData.maxValue;
+                    formlyConfig.validation.messages = {
+                        ...formlyConfig.validation?.messages,
+                        max: simpleValidationMessage,
+                    };
+                }
+            }
+            // Apply pattern validation if allowedCharacters is defined
+            if (control.specificControlData?.allowedCharacters) {
+                simpleValidationMessage = simpleValidationMessage =
+                    Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'simpleValidation');
+                formlyConfig.validators = {
+                    ...formlyConfig.validators,
+                    customPattern: {
+                        expression: (c) => {
+                            if (!c.value)
+                                return true;
+                            try {
+                                const regex = new RegExp(pattern);
+                                return regex.test(c.value);
+                            }
+                            catch {
+                                return false;
+                            }
+                        },
+                        message: simpleValidationMessage ||
+                            'Value does not match the required pattern',
+                    },
+                };
+                formlyConfig.validation.messages = {
+                    ...formlyConfig.validation?.messages,
+                    pattern: simpleValidationMessage,
+                };
+            }
+            // Apply maxLength validation if maxCharacters is defined
+            if (control.specificControlData?.maxCharacters) {
+                formlyConfig.props.maxLength =
+                    control.specificControlData?.maxCharacters;
+                formlyConfig.validation.messages = {
+                    ...formlyConfig.validation?.messages,
+                    maxLength: simpleValidationMessage,
+                };
+            }
+            if (control.specificControlData?.allowOnlyFuture ||
+                control.specificControlData?.allowOnlyPast) {
+                formlyConfig.type = 'datepicker';
+                const checkDateValidation = {
+                    checkDate: {
+                        expression: (c, field) => {
+                            simpleValidationMessage =
+                                Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'simpleValidation');
+                            const currentDate = new Date();
+                            currentDate.setHours(0, 0, 0, 0);
+                            if (control.specificControlData?.allowOnlyFuture) {
+                                if (!c.value || c.value === '')
+                                    return true;
+                                return c.value > currentDate;
+                            }
+                            if (control.specificControlData?.allowOnlyPast) {
+                                if (!c.value || c.value === '')
+                                    return true;
+                                return c.value < currentDate;
+                            }
+                            return true;
+                        },
+                        message: (error, field) => {
+                            return simpleValidationMessage;
+                        },
+                    },
+                };
+                formlyConfig.validators = {
+                    ...formlyConfig.validators,
+                    ...checkDateValidation,
+                };
+            }
+        }
+        //control.specificControlData.type === 4  is phone
+        if (control.specificControlData?.type === 4) {
+            var phoneErrorLabel = this.flux?.find((f) => f?.config?.componentCollected === control?.identifier)?.config?.phoneErrorLabel;
+            var phoneErrorLabelValue = '';
+            if (phoneErrorLabel != null && Array.isArray(phoneErrorLabel)) {
+                phoneErrorLabelValue =
+                    phoneErrorLabel.find((l) => l.languageIso === this.currentLanguageIso)?.value ?? '';
+            }
+            formlyConfig.validators = {
+                phoneValid: {
+                    expression: (cont) => {
+                        const value = cont.value;
+                        const phonePattern = new RegExp('^(\\+4|)?(07[0-8]{1}[0-9]{1}|02[0-9]{2}|03[0-9]{2}){1}?(\\s|\\.|-)?([0-9]{3}(\\s|\\.|-|)){2}$');
+                        if (value && !phonePattern.test(value)) {
+                            cont.setErrors({ invalidPhoneNumber: true });
+                            return false;
+                        }
+                        return true;
+                    },
+                    message: phoneErrorLabelValue,
+                },
+            };
+        }
+        if (control.specificControlData?.type === 2) {
+            const checkDate2Validation = {
+                checkDate2: {
+                    expression: (c, field) => {
+                        var dateValue = c.value;
+                        if (!dateValue && control.specificControlData?.isMandatory) {
+                            simpleValidationMessage =
+                                Utils.findErrorTranslationValueOrDefault(control.errorsTranslations, this.currentLanguageIso, 'isMandatoryValidation');
+                            return false;
+                        }
+                        if (isNaN(Date.parse(dateValue)) &&
+                            control.specificControlData?.isMandatory)
+                            return false;
+                        return true;
+                    },
+                    message: (error, field) => {
+                        if (simpleValidationMessage === '')
+                            return 'Please enter a valid date';
+                        return simpleValidationMessage;
+                    },
+                },
+            };
+            formlyConfig.validators = {
+                ...formlyConfig.validators,
+                ...checkDate2Validation,
+            };
+        }
+        return formlyConfig;
+    }
+    async buildPresentationFormFieldAsync(step, control) {
+        let formlyConfig = { props: {} };
+        formlyConfig.type = 'formly-paragraph';
+        formlyConfig.className = 'component-text-field';
+        formlyConfig.props['design'] = this.appModel.generatedCss;
+        var translatedTitle = control.translations.find((d) => d.languageIso == this.currentLanguageIso)
+            ?.value ??
+            control.title ??
+            '';
+        if (control.type == PresentationControlType.Paragraph) {
+            const paragraphControl = control;
+            var translatedDescription = paragraphControl.specificControlData.descriptionTranslations.find((d) => d.languageIso == this.currentLanguageIso)?.value ?? '';
+            var translatedParagraphTitle = paragraphControl.specificControlData.text.find((d) => d.languageIso == this.currentLanguageIso)?.value ?? '';
+            formlyConfig.defaultValue = translatedDescription;
+            formlyConfig.props['translatedDescription'] = translatedDescription;
+            formlyConfig.props['translatedParagraphTitle'] =
+                translatedParagraphTitle;
+            formlyConfig.type = 'formly-paragraph';
+            formlyConfig.className = 'component-text-field';
+        }
+        else if (control.type == PresentationControlType.Download) {
+            formlyConfig = this.CreateDownloadDocsFieldConfig(control);
+        }
+        else if (control.type == PresentationControlType.View) {
+            formlyConfig = this.CreateViewDocsFieldConfig(control);
+        }
+        else if (control.type == PresentationControlType.Status) {
+            let statusName = this.appModel.statuses.find((s) => s.id === this.fillData?.metadata.statusId)?.name || 'no status name';
+            formlyConfig.defaultValue = statusName;
+            formlyConfig.type = 'formly-paragraph';
+            formlyConfig.className = 'component-text-field';
+        }
+        else {
+            if (control.type == PresentationControlType.FluxComponent &&
+                this.controlIdsWithValues &&
+                control.collectionControlIdentifier) {
+                const fillValue = this.controlIdsWithValues[control.collectionControlIdentifier];
+                if (fillValue) {
+                    switch (typeof fillValue) {
+                        case 'boolean':
+                            formlyConfig.defaultValue = fillValue ? '&check;' : '&cross;';
+                            break;
+                        default:
+                            if (fillValue?.name) {
+                                formlyConfig.defaultValue = fillValue.name;
+                            }
+                            else {
+                                formlyConfig.defaultValue = fillValue;
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+        formlyConfig.id = control.identifier;
+        formlyConfig.props['isDisplayMode'] = true;
+        formlyConfig.props['collectionControlIdentifier'] =
+            control.collectionControlIdentifier;
+        formlyConfig.props['label'] = translatedTitle;
+        formlyConfig.props['langIso'] = this.currentLanguageIso;
+        this.formlyPresentationFields.push(formlyConfig);
+        return formlyConfig;
+    }
+    async buildApiMethodFormFieldAsync(step, control) {
+        let formlyConfig = { props: {} };
+        formlyConfig.type = 'formly-paragraph';
+        formlyConfig.className = 'component-text-field';
+        formlyConfig.props['design'] = this.appModel.generatedCss;
+        var translatedTitle = control.translations.find((d) => d.languageIso == this.currentLanguageIso)
+            ?.value ??
+            control.title ??
+            '';
+        formlyConfig.id = control.identifier;
+        formlyConfig.props['isDisplayMode'] = true;
+        formlyConfig.props['apiMethodId'] = control.apiMethodId;
+        formlyConfig.props['apiMethodFieldId'] = control.apiMethodFieldId;
+        formlyConfig.props['label'] = translatedTitle;
+        if (control.apiMethodFieldId) {
+            const val = this.findInApiCallsResponses(control.apiMethodFieldId);
+            formlyConfig.defaultValue = val;
+        }
+        this.formlyPresentationFields.push(formlyConfig);
+        return formlyConfig;
+    }
+    attachToDependentDictionaryIfNecessary(dependentDictionary, formlyConfig) {
+        // Handle dictionary dependencies
+        if (dependentDictionary &&
+            dependentDictionary.dictionaryControlIdentifier) {
+            const parentKey = dependentDictionary.dictionaryControlIdentifier;
+            const dependentValueIds = dependentDictionary.dependentValueIds || [];
+            formlyConfig.expressions = {
+                hide: (field) => {
+                    const shouldShow = this.shouldShowDependentField(parentKey, dependentValueIds, this.model);
+                    return !shouldShow;
+                },
+            };
+        }
+    }
+    attachToValueChanges(controlId, options) {
+        options.props['onSelectedValueChanged'] = async (val) => {
+            this.model[controlId] = val;
+            var referenceDictionaries = Array.from(this.dictionaryMap.values()).filter((d) => d.referenceId == val.dictionaryId);
+            if (referenceDictionaries?.length > 0) {
+                this.removeReferenceFields(options);
+                var referenceDictionariesWithFilteredValues = this.createReferenceDictionariesFromSelectedValue(referenceDictionaries, val);
+                const parentSpecificData = options.props?.['specificData'];
+                await this.addReferenceDictionaryFieldsIfNecessary(referenceDictionariesWithFilteredValues, options, options.type, parentSpecificData?.relatedDictionariesTranslations || []);
+            }
+            else {
+                this.removeReferenceFields(options);
+            }
+            this.updateFormlyConfig();
+        };
+    }
+    createReferenceDictionariesFromSelectedValue(allDictionaries, selectedValue) {
+        const newDictionaries = [];
+        allDictionaries.forEach((dictionary) => {
+            const filteredValues = dictionary.values?.filter((value) => value.referenceValues.some((refValue) => refValue.id === selectedValue.id)) || [];
+            if (filteredValues.length > 0) {
+                const newDictionary = {
+                    ...dictionary,
+                    values: filteredValues,
+                };
+                newDictionaries.push(newDictionary);
+            }
+        });
+        return newDictionaries;
+    }
+    shouldShowDependentField(parentKey, dependentValueIds, model = {}) {
+        // Retrieve the value of the parent dictionary control
+        const parentValue = this.getNestedValue(model, parentKey);
+        const idValue = parentValue?.id
+            ? parentValue.id
+            : parentValue;
+        // Check if the parent value is in the dependentValueIds
+        if (parentValue && dependentValueIds.includes(idValue)) {
+            return true;
+        }
+        return false;
+    }
+    getNestedValue(obj, path) {
+        const keys = path.split('.');
+        let value = obj;
+        for (const key of keys) {
+            value = value[key];
+            if (value === undefined) {
+                return undefined;
+            }
+        }
+        return value;
+    }
+    submit() {
+        console.log('Form Data:', this.form.value);
+        if (this.form.invalid) {
+            console.log('Form data has validation errors.');
+            this.scrollToErrorService.scrollToFirstError(this.form);
+        }
+    }
+    /**
+     * Public method to trigger scroll to first error - can be called from other components
+     */
+    scrollToFirstValidationError() {
+        this.scrollToErrorService.scrollToFirstError(this.form);
+    }
+    /**
+     * Public method to scroll to a specific field by name
+     */
+    scrollToField(fieldName) {
+        this.scrollToErrorService.scrollToField(fieldName);
+    }
+    /**
+     * Debug method to help troubleshoot scroll issues
+     */
+    debugFormElements() {
+        this.scrollToErrorService.debugLogFormElements();
+    }
+    async constructDictionary(control, options) {
+        const specificData = control.specificControlData;
+        options.type =
+            specificData.showAsRadioButtonsList === true
+                ? `formly-radio`
+                : `formly-dictionary-dropdown-tree`;
+        options.props['specificData'] = specificData;
+        const dictionaryUuid = specificData.dictionaryUUID;
+        if (dictionaryUuid) {
+            const dictionary = this.dictionaryMap.get(dictionaryUuid);
+            if (dictionary) {
+                if (dictionary.referenceId) {
+                    options.props['dictionaryId'] = dictionaryUuid;
+                    this.constructDictionaryWithReferences(dictionary, options, specificData);
+                    this.attachToValueChanges(control.identifier, options);
+                }
+                else {
+                    options.type =
+                        specificData.showAsRadioButtonsList === true
+                            ? 'formly-radio'
+                            : 'formly-dictionary-dropdown-tree';
+                    options.props['dictionaryId'] = dictionaryUuid;
+                    this.constructDictionaryWithReferences(dictionary, options, specificData);
+                    this.attachToValueChanges(control.identifier, options);
+                }
+            }
+            else {
+                console.warn(`Dictionary not found for UUID ${dictionaryUuid}`);
+            }
+        }
+        else {
+            console.warn(`UUID not found for dictionary ID ${specificData.dictionaryId}`);
+        }
+    }
+    findDictionaryValueObject(dictionary, value) {
+        if (!dictionary ||
+            !dictionary.values ||
+            value === null ||
+            value === undefined) {
+            return undefined;
+        }
+        if (typeof value === 'object' && value?.id != null) {
+            return dictionary.values.find((v) => v.id === value.id);
+        }
+        else if (typeof value === 'number' || typeof value === 'string') {
+            const valueId = Number(value);
+            if (!isNaN(valueId)) {
+                return dictionary.values.find((v) => v.id === valueId);
+            }
+        }
+        return undefined;
+    }
+    async initializeReferenceFields(fields, rootConfig = this.formlyConfig) {
+        if (!fields)
+            return;
+        const fieldsToProcess = [...fields];
+        for (const field of fieldsToProcess) {
+            const fieldKey = field.key;
+            if (fieldKey &&
+                field.props?.['dictionaryId'] &&
+                field.props?.['specificData']) {
+                const control = this.form.get(fieldKey);
+                const specificData = field.props['specificData'];
+                const dictionaryUuid = field.props['dictionaryId'];
+                const mainDictionary = this.dictionaryMap.get(dictionaryUuid);
+                let valueToUse = null;
+                if (control && control.value !== null && control.value !== undefined) {
+                    valueToUse = control.value;
+                }
+                else if (field.defaultValue !== null &&
+                    field.defaultValue !== undefined) {
+                    valueToUse = field.defaultValue;
+                }
+                else if (this.model &&
+                    this.model[fieldKey] !== null &&
+                    this.model[fieldKey] !== undefined) {
+                    valueToUse = this.model[fieldKey];
+                }
+                let selectedValueObject = null;
+                if (valueToUse !== null && mainDictionary?.id != null) {
+                    selectedValueObject = this.findDictionaryValueObject(mainDictionary, valueToUse);
+                }
+                const fieldConfigInTree = this.findFieldByKey(rootConfig, fieldKey);
+                if (!fieldConfigInTree) {
+                    continue;
+                }
+                this.removeReferenceFields(fieldConfigInTree);
+                if (selectedValueObject &&
+                    selectedValueObject.id != null &&
+                    mainDictionary?.id != null) {
+                    const potentialReferenceDictionaries = Array.from(this.dictionaryMap.values()).filter((dict) => dict.referenceId === mainDictionary.id);
+                    if (potentialReferenceDictionaries.length > 0) {
+                        const referenceDictionariesToShow = this.createReferenceDictionariesFromSelectedValue(potentialReferenceDictionaries, selectedValueObject);
+                        if (referenceDictionariesToShow.length > 0) {
+                            await this.addReferenceDictionaryFieldsIfNecessary(referenceDictionariesToShow, fieldConfigInTree, fieldConfigInTree.type, specificData?.relatedDictionariesTranslations || []);
+                        }
+                    }
+                }
+            }
+            if (field.fieldGroup && field.fieldGroup.length > 0) {
+                await this.initializeReferenceFields(field.fieldGroup, rootConfig);
+            }
+        }
+        if (fields === this.formlyConfig ||
+            fields === this.formlyConfig[0]?.fieldGroup) {
+            this.updateFormlyConfig();
+            this.formlyConfigUpdated.emit();
+            this.cdRef.detectChanges();
+        }
+    }
+    constructDictionaryWithReferences(dictionary, options, dictionaryControlData) {
+        if (options.props) {
+            var currentLanguageId = Utils.findLanguageIdByIso(this.availableLanguages, this.currentLanguageIso);
+            // Pass preloaded dictionary data to formly component
+            options.props['dictionaryData'] = dictionary;
+            options.props['languages'] = this.availableLanguages;
+            options.props['preloadedDictionaries'] = this.dictionaryMap;
+            options.props['usePreloadedData'] = true;
+            options.props.options = dictionary.values?.map((value) => ({
+                value: value,
+                label: Utils.findValueTranslation(value.valueTranslations, currentLanguageId) || value.name,
+                currentLanguageIso: this.currentLanguageIso,
+                relatedDictionariesTranslations: dictionaryControlData.relatedDictionariesTranslations,
+            }));
+            options.props['selectedRelatedDictionaries'] =
+                dictionaryControlData.selectedRelatedDictionaries || [];
+            let initialValueObject = null;
+            const controlKey = options.key;
+            const dictionaryDefaultValueId = dictionaryControlData.dictionaryDefaultValueId;
+            if (!(this.model && this.model[controlKey] != null) &&
+                dictionaryDefaultValueId != null) {
+                initialValueObject = this.findAndMapDefaultValue(dictionary, dictionaryDefaultValueId);
+            }
+            options.defaultValue = initialValueObject;
+            // Pass default value ID to formly component
+            options.props['dictionaryDefaultValueId'] = dictionaryDefaultValueId;
+            const controlId = options.key;
+            if (this.fillData && this.fillData.flux) {
+                for (const step of this.fillData.flux) {
+                    for (const section of step.sections) {
+                        const control = section.controls.find((ctrl) => ctrl.controlId === controlId);
+                        if (control && control.fillValue && control.fillValue.name) {
+                            options.props['value'] = control.fillValue.name;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        this.updateFormlyConfig();
+    }
+    async addReferenceDictionaryFieldsIfNecessary(referrencedDictionaries, parentDictionaryField, type, relatedDictionariesTranslations) {
+        if (referrencedDictionaries.length > 0) {
+            const selectedRelatedDictionaries = parentDictionaryField.props?.['selectedRelatedDictionaries'] || [];
+            const selectedDictionaries = referrencedDictionaries.filter((dict) => selectedRelatedDictionaries.includes(dict.uuid));
+            selectedDictionaries.forEach((referenceDictionary) => {
+                const referenceDictionaryUuid = referenceDictionary.uuid;
+                const componentOnlyForConfig = this.flux
+                    .flatMap((s) => s.sections)
+                    .flatMap((sec) => sec.controls)
+                    .find((ctrl) => ctrl?.specificControlData?.dictionaryUUID ===
+                    referenceDictionaryUuid && ctrl?.isOnlyForConfig === true);
+                const newFieldKey = componentOnlyForConfig?.identifier ??
+                    `extra_${referenceDictionaryUuid}`;
+                let referenceDictionaryLabel = referenceDictionary.name;
+                const specificTranslationValue = relatedDictionariesTranslations
+                    .find((d) => d.dictionaryUUID == referenceDictionaryUuid)
+                    ?.translations?.find((t) => t.languageIso == this.currentLanguageIso)?.value;
+                if (specificTranslationValue &&
+                    specificTranslationValue.trim() !== '') {
+                    referenceDictionaryLabel = specificTranslationValue;
+                }
+                else {
+                    referenceDictionaryLabel = '';
+                }
+                const currentLanguageId = Utils.findLanguageIdByIso(this.availableLanguages, this.currentLanguageIso);
+                const newField = {
+                    key: newFieldKey,
+                    type: type,
+                    props: {
+                        label: referenceDictionaryLabel,
+                        design: this.design,
+                        dictionaryId: referenceDictionaryUuid,
+                        dictionaryData: referenceDictionary,
+                        languages: this.availableLanguages,
+                        preloadedDictionaries: this.dictionaryMap,
+                        usePreloadedData: true,
+                        currentLanguageIso: this.currentLanguageIso,
+                        currentLanguageId: currentLanguageId,
+                        required: true,
+                        attributes: {
+                            style: this.styleObjectToStringExceptBackground(this.design[`.font-list`] || {}),
+                        },
+                        options: referenceDictionary.values?.map((value) => ({
+                            value: value,
+                            label: Utils.findValueTranslation(value.valueTranslations, currentLanguageId) || value.name,
+                            currentLanguageIso: this.currentLanguageIso,
+                        })),
+                    },
+                };
+                if (referenceDictionary.defaultValueId) {
+                    const defaultVal = this.findAndMapDefaultValue(referenceDictionary, referenceDictionary.defaultValueId);
+                    if (defaultVal) {
+                        newField.defaultValue = defaultVal;
+                    }
+                }
+                const parentFieldGroup = parentDictionaryField.parent
+                    ? parentDictionaryField.parent.fieldGroup
+                    : null;
+                if (parentFieldGroup) {
+                    const parentIndex = parentFieldGroup.findIndex((field) => field.key === parentDictionaryField.key);
+                    if (parentIndex !== -1) {
+                        const endIndex = this.findLastChildIndex(parentFieldGroup, parentIndex);
+                        const percentageToAdd = this.getExistingPercentage(parentFieldGroup, parentIndex);
+                        newField.className = percentageToAdd === 0
+                            ? parentDictionaryField.className
+                            : this.getPercentageClassName(percentageToAdd);
+                        parentFieldGroup.splice(endIndex + 1, 0, newField);
+                        const classNameToAdd = type === 'radio' ? ` component-radio` : ` component-data`;
+                        newField.className += classNameToAdd;
+                        this.attachToValueChanges(newFieldKey, newField);
+                        this.updateFormlyConfig();
+                    }
+                }
+            });
+        }
+    }
+    getExistingPercentage(fields, index) {
+        let percentage = 0;
+        const field = fields[index];
+        const className = field.className;
+        if (field.type?.toString() !== StepControlType.NewRow.toString()) {
+            if (className && className.startsWith('percentage-width-')) {
+                percentage =
+                    (parseInt(className.replace('percentage-width-', ''), 10) * 100) / 12;
+            }
+            else if (className && className.startsWith('pixel-width-')) {
+                const pixels = parseInt(className.replace('pixel-width-', ''), 10);
+                percentage = (pixels / 1000) * 100;
+            }
+        }
+        return percentage;
+    }
+    calculateRemainingPercentageForRange(fields, startIndex, endIndex) {
+        let remainingPercentage = 100;
+        for (let i = startIndex; i <= endIndex; i++) {
+            const percentage = this.getExistingPercentage(fields, i);
+            remainingPercentage -= percentage;
+        }
+        return Math.max(remainingPercentage, 0);
+    }
+    removeReferenceFields(currentFormlyFieldConfig) {
+        const referredInDictionariesUUIds = currentFormlyFieldConfig.props?.['dictionaryData']
+            ?.referredInDictionariesUUIds;
+        if (Array.isArray(referredInDictionariesUUIds)) {
+            const parentFieldGroup = currentFormlyFieldConfig.parent
+                ? currentFormlyFieldConfig.parent.fieldGroup
+                : null;
+            if (parentFieldGroup) {
+                const parentIndex = parentFieldGroup.findIndex((field) => field.key === currentFormlyFieldConfig.key);
+                if (parentIndex !== -1) {
+                    for (const item of referredInDictionariesUUIds) {
+                        const idToFind = 'extra_' + item;
+                        for (let i = parentFieldGroup.length - 1; i > parentIndex; i--) {
+                            const currentFieldKey = parentFieldGroup[i].key?.toString();
+                            if (currentFieldKey && currentFieldKey === idToFind) {
+                                this.clearFormControlValue(idToFind);
+                                parentFieldGroup.splice(i, 1);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async addChildDictionaryField(childDictionaryUuid, parentDictionaryField, type, relatedDictionariesTranslations) {
+        if (childDictionaryUuid) {
+            const childDictionary = this.dictionaryMap.get(childDictionaryUuid);
+            if (childDictionary) {
+                let childDictionaryLabel = childDictionary.name;
+                const translation = relatedDictionariesTranslations
+                    .find((d) => d.dictionaryUUID == childDictionaryUuid)
+                    ?.translations.find((t) => t.languageIso == this.currentLanguageIso)
+                    ?.value || '';
+                if (translation) {
+                    childDictionaryLabel = translation;
+                }
+                const newField = {
+                    key: `${parentDictionaryField.key}_child_${childDictionaryUuid}`,
+                    type: type,
+                    props: {
+                        label: childDictionaryLabel,
+                        dictionaryData: childDictionary,
+                        languages: this.availableLanguages,
+                        preloadedDictionaries: this.dictionaryMap,
+                        options: childDictionary.values?.map((value) => ({
+                            value: value.id,
+                            label: value.name,
+                        })),
+                        required: true,
+                        attributes: {
+                            style: this.styleObjectToStringExceptBackground(this.design[`.font-list`] || {}),
+                        },
+                    },
+                    hooks: {
+                        onInit: (field) => {
+                            const unsubscribe$ = new Subject();
+                            this.fieldUnsubscribeSubjects.push(unsubscribe$);
+                            field.formControl?.valueChanges
+                                .pipe(takeUntil(unsubscribe$))
+                                .subscribe(async (selectedValue) => {
+                                const selectedOption = childDictionary.values?.find((val) => val.id === selectedValue);
+                                if (selectedOption && selectedOption.childDictionaryUUID) {
+                                    await this.addChildDictionaryField(selectedOption.childDictionaryUUID, field, type, relatedDictionariesTranslations);
+                                }
+                                else {
+                                    this.removeChildFields(field);
+                                    this.updateFormlyConfig();
+                                }
+                            });
+                            field.hooks.onDestroy = () => {
+                                unsubscribe$.next();
+                                unsubscribe$.complete();
+                            };
+                        },
+                    },
+                };
+                const parentFieldGroup = parentDictionaryField.parent
+                    ? parentDictionaryField.parent.fieldGroup
+                    : null;
+                if (parentFieldGroup) {
+                    const parentIndex = parentFieldGroup.findIndex((field) => field.key === parentDictionaryField.key);
+                    if (parentIndex !== -1) {
+                        const endIndex = this.findLastChildIndex(parentFieldGroup, parentIndex);
+                        const percentageToAdd = this.getExistingPercentage(parentFieldGroup, parentIndex);
+                        newField.className = this.getPercentageClassName(percentageToAdd);
+                        parentFieldGroup.splice(endIndex + 1, 0, newField);
+                        const classNameToAdd = type === 'radio' ? ` component-radio` : ` component-data`;
+                        newField.className += classNameToAdd;
+                        //this.attachToValueChanges(newFieldKey, newField);
+                        this.updateFormlyConfig();
+                    }
+                }
+            }
+            else {
+                console.warn(`Child dictionary not found for UUID ${childDictionaryUuid}`);
+            }
+        }
+    }
+    onCompletion() {
+        console.log('Origin form completed successfully');
+        this.completionEvent.emit();
+    }
+    findLastChildIndex(fields, parentIndex) {
+        const parentKeyPrefix = `${fields[parentIndex].key}_`;
+        let lastIndex = parentIndex;
+        for (let i = parentIndex + 1; i < fields.length; i++) {
+            if (fields[i].key?.toString().startsWith(parentKeyPrefix)) {
+                lastIndex = i;
+            }
+            else {
+                break;
+            }
+        }
+        return lastIndex;
+    }
+    findFieldByKey(fields, key) {
+        if (!fields)
+            return null;
+        for (const field of fields) {
+            if (field.type === 'stepper' && field.fieldGroup) {
+                const foundInStepper = this.findFieldByKey(field.fieldGroup, key);
+                if (foundInStepper)
+                    return foundInStepper;
+            }
+            if (field.key === key) {
+                return field;
+            }
+            if (field.fieldGroup) {
+                const found = this.findFieldByKey(field.fieldGroup, key);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    removeChildFields(parentField) {
+        const parentFieldGroup = parentField.parent
+            ? parentField.parent.fieldGroup
+            : null;
+        if (parentFieldGroup) {
+            const parentIndex = parentFieldGroup.findIndex((field) => field.key === parentField.key);
+            if (parentIndex !== -1) {
+                const parentKeyPrefix = `${parentField.key}_child_`;
+                // Remove only the relevant child fields
+                for (let i = parentFieldGroup.length - 1; i > parentIndex; i--) {
+                    const currentFieldKey = parentFieldGroup[i].key?.toString();
+                    if (currentFieldKey && currentFieldKey.startsWith(parentKeyPrefix)) {
+                        this.clearFormControlValue(currentFieldKey);
+                        parentFieldGroup.splice(i, 1);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * NEW: Load ALL dictionaries needed for this app using the new app-based endpoint
+     */
+    async loadAllRequiredDictionaries() {
+        if (!this.appModel?.applicationUuid) {
+            console.warn('No app UUID available for dictionary loading');
+            return;
+        }
+        try {
+            const response = await firstValueFrom(this.service.loadAppDictionaries(this.appModel.applicationUuid, EnvironmentType.Config));
+            if (!response.success) {
+                console.error('❌ Backend failed to load dictionaries:', response.errors);
+                return;
+            }
+            // Simple assignment - ALL dictionaries and dependencies already loaded by backend
+            Object.entries(response.dictionaries).forEach(([uuid, dict]) => {
+                this.dictionaryMap.set(uuid, dict);
+            });
+        }
+        catch (error) {
+            console.error('❌ Failed to load app dictionaries:', error);
+        }
+    }
+    clearFormControlValue(fieldKey) {
+        const keys = fieldKey.split('.');
+        let control = this.form;
+        let model = this.model;
+        for (let i = 0; i < keys.length - 1; i++) {
+            control = control.get(keys[i]);
+            model = model[keys[i]];
+        }
+        const finalKey = keys[keys.length - 1];
+        if (control && control.get(finalKey)) {
+            control.removeControl(finalKey);
+        }
+        if (model && model[finalKey] !== undefined) {
+            delete model[finalKey];
+        }
+    }
+    findField(fields, key) {
+        for (const field of fields) {
+            if (field.key === key) {
+                return field;
+            }
+            if (field.fieldGroup) {
+                const nestedField = this.findField(field.fieldGroup, key);
+                if (nestedField) {
+                    return nestedField;
+                }
+            }
+        }
+        return null;
+    }
+    populateModelWithFillData(fillData) {
+        if (fillData) {
+            let auxModel = ModelPopulationHelper.populateModelWithFillData(fillData, this.flux, this.dictionaryMap, this.availableLanguages);
+            this.model = { ...auxModel };
+            this.cdRef.detectChanges();
+        }
+    }
+    findAndMapDefaultValue(dictionary, defaultValueId) {
+        return ModelPopulationHelper.findAndMapDefaultValue(dictionary, defaultValueId, this.availableLanguages);
+    }
+    updateFormlyConfig() {
+        this.formlyConfig = [...this.formlyConfig];
+    }
+    unsubscribeFromAllFields() {
+        for (const subject of this.fieldUnsubscribeSubjects) {
+            subject.next();
+            subject.complete();
+        }
+        this.fieldUnsubscribeSubjects = [];
+    }
+    ngOnDestroy() {
+        this.unsubscribeFromAllFields();
+        if (this.collectorHandlerSubscriptions) {
+            this.collectorHandlerSubscriptions.unsubscribe();
+        }
+        if (this.actionStepSubscriptions) {
+            this.actionStepSubscriptions.unsubscribe();
+        }
+        if (this.actionStepHandler) {
+            this.actionStepHandler.destroy();
+        }
+    }
+    constructButtons(buttonsConfig) {
+        if (!buttonsConfig || buttonsConfig.length === 0) {
+            return [];
+        }
+        return buttonsConfig.map((button) => ({
+            type: button.value.toLowerCase(),
+            label: button.translations?.[this.currentLanguageIso] || button.value,
+            styleKey: `.button-${button.value.toLowerCase()}`,
+        }));
+    }
+    styleObjectToStringExceptBackground(styleObj) {
+        return Object.entries(styleObj)
+            .filter(([key, value]) => key !== 'background-color')
+            .map(([key, value]) => `${key}: ${value}`)
+            .join('; ');
+    }
+    validateMethodApi(data) {
+        if (data.apiId === undefined || data.appId === undefined) {
+            return of(false);
+        }
+        return this.applicationDataService.validateApi(data).pipe(map((response) => {
+            console.log('API validation response:', response);
+            return !!response;
+        }), catchError((error) => {
+            console.error('Error validating ' + data.data, error);
+            return of(false);
+        }));
+    }
+    /**
+     * Public method to clear the saving after actions state
+     * Called by stepper component after saveAppDataStep completes
+     */
+    clearSavingAfterActionsState() {
+        if (this.isSavingAfterActions) {
+            this.isSavingAfterActions = false;
+            this.isLoading = false;
+            this.cdRef.detectChanges();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CollectorFormComponent, deps: [{ token: i1.DictionaryService }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i2.ProxyService }, { token: i3.LabelService }, { token: i4.ApplicationDataService }, { token: i5.LanguageService }, { token: i6.OriginFormAuthService }, { token: i7.FormsService }, { token: i8.ConfigService }, { token: i9.TranslationService }, { token: i10.OriginFormSignalrHandlerService }, { token: i11.ActionStepHandler }, { token: i12.ScrollToErrorService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CollectorFormComponent, selector: "app-origin-form", inputs: { configComponent: "configComponent", configUuid: "configUuid", currentStepId: "currentStepId", appModel: "appModel", signBaseUrl: "signBaseUrl", currentLanguageIso: "currentLanguageIso", fillData: "fillData", env: "env", showDisplayMode: "showDisplayMode", showLanguageSelector: "showLanguageSelector", isDemoMode: "isDemoMode", isDebug: "isDebug", appDataUuid: "appDataUuid", blockPreviousStep: "blockPreviousStep", dataUrlId: "dataUrlId", noButtonsInView: "noButtonsInView" }, outputs: { completionEvent: "completionEvent" }, viewQueries: [{ propertyName: "formlyFields", predicate: FormlyField, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div *ngIf=\"isLoading\" class=\"loading-overlay\">\n  <mat-spinner></mat-spinner>\n</div>\n<div [hidden]=\"isLoading\">\n  <div *ngIf=\"showLanguageSelector\" appearance=\"outline\" class=\"right-aligned\">\n    <button [matMenuTriggerFor]=\"flags\" mat-icon-button class=\"m-r-5\">\n      <img\n        [src]=\"returnFLag(currentLanguageIso)\"\n        class=\"rounded-circle object-cover icon-20\"\n      />\n    </button>\n    <mat-menu #flags=\"matMenu\" class=\"cardWithShadow\">\n      <button\n        mat-menu-item\n        *ngFor=\"let lang of applicationLanguages()\"\n        (click)=\"changeLanguage(lang.iso)\"\n      >\n        <div class=\"d-flex align-items-center\">\n          <img\n            [src]=\"returnFLag(lang.iso)\"\n            class=\"rounded-circle object-cover icon-20\"\n          />\n          <span class=\"mat-subtitle-1 f-s-14\">{{ lang.name }}</span>\n        </div>\n      </button>\n    </mat-menu>\n  </div>\n\n  <br />\n  <div class=\"form-container\">\n    <form [formGroup]=\"form\" (ngSubmit)=\"submit()\">\n      <formly-form\n        [model]=\"model\"\n        [fields]=\"formlyConfig\"\n        [options]=\"options\"\n        [form]=\"form\"\n      ></formly-form>\n    </form>\n  </div>\n</div>\n", styles: ["@import\"https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700&display=swap\";@import\"https://fonts.googleapis.com/icon?family=Material+Icons\";@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-bold-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-bold-webfont.woff) format(\"woff\");font-weight:700;font-style:normal}@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-regular-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-regular-webfont.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-thin-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-thin-webfont.woff) format(\"woff\");font-weight:200;font-style:normal}@font-face{font-family:Sora Light;src:url(/assets/fonts/Sora-Light.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Sora Regular;src:url(/assets/fonts/Sora-Regular.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Sora ExtraBold;src:url(/assets/fonts/Sora-ExtraBold.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Light;src:url(/assets/fonts/Figtree-Light.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Regular;src:url(/assets/fonts/Figtree-Regular.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Bold;src:url(/assets/fonts/Figtree-Bold.ttf) format(\"truetype\");font-weight:400;font-style:normal}.loader{border-top:16px solid blue;border-right:16px solid green;border-bottom:16px solid red;border-left:16px solid pink}:host ::ng-deep .mat-mdc-text-field-wrapper .mdc-line-ripple{display:none!important}.right-aligned{display:flex;justify-content:flex-end!important}.flag-icon{width:20px;height:20px;margin-right:8px;vertical-align:middle}.rounded-circle{border-radius:50%}.object-cover{object-fit:cover}.m-r-8{margin-right:8px}.icon-20{width:20px;height:20px}.loading-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:#ffffffb3;display:flex;justify-content:center;align-items:center;z-index:9999}\n"], dependencies: [{ kind: "directive", type: i13.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i13.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i14.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i14.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i14.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i15.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i15.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i15.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "component", type: i16.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i17.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "component", type: i18.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CollectorFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-origin-form', template: "<div *ngIf=\"isLoading\" class=\"loading-overlay\">\n  <mat-spinner></mat-spinner>\n</div>\n<div [hidden]=\"isLoading\">\n  <div *ngIf=\"showLanguageSelector\" appearance=\"outline\" class=\"right-aligned\">\n    <button [matMenuTriggerFor]=\"flags\" mat-icon-button class=\"m-r-5\">\n      <img\n        [src]=\"returnFLag(currentLanguageIso)\"\n        class=\"rounded-circle object-cover icon-20\"\n      />\n    </button>\n    <mat-menu #flags=\"matMenu\" class=\"cardWithShadow\">\n      <button\n        mat-menu-item\n        *ngFor=\"let lang of applicationLanguages()\"\n        (click)=\"changeLanguage(lang.iso)\"\n      >\n        <div class=\"d-flex align-items-center\">\n          <img\n            [src]=\"returnFLag(lang.iso)\"\n            class=\"rounded-circle object-cover icon-20\"\n          />\n          <span class=\"mat-subtitle-1 f-s-14\">{{ lang.name }}</span>\n        </div>\n      </button>\n    </mat-menu>\n  </div>\n\n  <br />\n  <div class=\"form-container\">\n    <form [formGroup]=\"form\" (ngSubmit)=\"submit()\">\n      <formly-form\n        [model]=\"model\"\n        [fields]=\"formlyConfig\"\n        [options]=\"options\"\n        [form]=\"form\"\n      ></formly-form>\n    </form>\n  </div>\n</div>\n", styles: ["@import\"https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700&display=swap\";@import\"https://fonts.googleapis.com/icon?family=Material+Icons\";@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-bold-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-bold-webfont.woff) format(\"woff\");font-weight:700;font-style:normal}@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-regular-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-regular-webfont.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:ttrounds;src:url(/assets/fonts/ttrounds-thin-webfont.woff2) format(\"woff2\"),url(/assets/fonts/ttrounds-thin-webfont.woff) format(\"woff\");font-weight:200;font-style:normal}@font-face{font-family:Sora Light;src:url(/assets/fonts/Sora-Light.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Sora Regular;src:url(/assets/fonts/Sora-Regular.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Sora ExtraBold;src:url(/assets/fonts/Sora-ExtraBold.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Light;src:url(/assets/fonts/Figtree-Light.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Regular;src:url(/assets/fonts/Figtree-Regular.ttf) format(\"truetype\");font-weight:400;font-style:normal}@font-face{font-family:Figtree Bold;src:url(/assets/fonts/Figtree-Bold.ttf) format(\"truetype\");font-weight:400;font-style:normal}.loader{border-top:16px solid blue;border-right:16px solid green;border-bottom:16px solid red;border-left:16px solid pink}:host ::ng-deep .mat-mdc-text-field-wrapper .mdc-line-ripple{display:none!important}.right-aligned{display:flex;justify-content:flex-end!important}.flag-icon{width:20px;height:20px;margin-right:8px;vertical-align:middle}.rounded-circle{border-radius:50%}.object-cover{object-fit:cover}.m-r-8{margin-right:8px}.icon-20{width:20px;height:20px}.loading-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:#ffffffb3;display:flex;justify-content:center;align-items:center;z-index:9999}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DictionaryService }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i2.ProxyService }, { type: i3.LabelService }, { type: i4.ApplicationDataService }, { type: i5.LanguageService }, { type: i6.OriginFormAuthService }, { type: i7.FormsService }, { type: i8.ConfigService }, { type: i9.TranslationService }, { type: i10.OriginFormSignalrHandlerService }, { type: i11.ActionStepHandler }, { type: i12.ScrollToErrorService }], propDecorators: { formlyFields: [{
+                type: ViewChildren,
+                args: [FormlyField]
+            }], configComponent: [{
+                type: Input
+            }], configUuid: [{
+                type: Input
+            }], currentStepId: [{
+                type: Input
+            }], appModel: [{
+                type: Input
+            }], signBaseUrl: [{
+                type: Input
+            }], currentLanguageIso: [{
+                type: Input
+            }], fillData: [{
+                type: Input
+            }], env: [{
+                type: Input
+            }], showDisplayMode: [{
+                type: Input
+            }], showLanguageSelector: [{
+                type: Input
+            }], isDemoMode: [{
+                type: Input
+            }], isDebug: [{
+                type: Input
+            }], appDataUuid: [{
+                type: Input
+            }], blockPreviousStep: [{
+                type: Input
+            }], dataUrlId: [{
+                type: Input
+            }], noButtonsInView: [{
+                type: Input
+            }], completionEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"origin-form.component.js","sourceRoot":"","sources":["../../../../projects/origin-form/src/lib/origin-form.component.ts","../../../../projects/origin-form/src/lib/origin-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  ViewChildren,\n} from '@angular/core';\nimport { AbstractControl, FormControl, FormGroup } from '@angular/forms';\nimport {\n  FormlyField,\n  FormlyFieldConfig,\n  FormlyFormOptions,\n} from '@ngx-formly/core';\nimport {\n  Subject,\n  firstValueFrom,\n  startWith,\n  pairwise,\n  debounceTime,\n  switchMap,\n  catchError,\n  of,\n  takeUntil,\n  Observable,\n  map,\n  Subscription,\n} from 'rxjs';\nimport { LabelKeys } from './enums/label.keys';\nimport { ApiValidateRequest } from './models/application.model';\nimport {\n  DictionaryDto,\n  DictionaryValue,\n  DictionaryValueDto,\n} from './models/dictionary.model';\nimport {\n  FormModel,\n  DisplayModel,\n  GeneralDataModel,\n  StepsSettings,\n  FluxType,\n  DimensionType,\n  StepControlType,\n  ManualInputControlType,\n  PresentationParagraphControl,\n  DictionaryControlData,\n} from './models/forms.model';\nimport { LabelInfo, TranslationInfo } from './models/label-info.model';\nimport { Label } from './models/label.model';\nimport { Language } from './models/language.model';\nimport { DictionaryLabelInfo } from './others/dictionary-label-info';\nimport { EnvironmentType } from './others/environment-type';\nimport { CssRules, Utils } from './others/utils';\nimport { ApplicationDataService } from './services/applicationData.service';\nimport { LabelService } from './services/labels.service';\nimport { ProxyService } from './services/proxy.service';\nimport { DictionaryService } from './services/dictionary.service';\nimport { LanguageService } from './services/language.service';\nimport { OriginFormAuthService } from './origin-form-auth.service';\nimport { FormsService } from './services/forms.service';\nimport { InputConfig } from './origin-form-config.model';\nimport { ConfigService } from './others/config-service';\nimport { ModelPopulationHelper } from './model-population.helper';\nimport { TranslationService } from './services/translation.service';\nimport {\n  OperationResult,\n  OriginFormSignalrHandlerService,\n} from './services/origin-form-signalr-handler.service';\nimport { ActionStepHandler } from './action-step-handler';\nimport { ScrollToErrorService } from './services/scroll-to-error.service';\nimport { FormCssHelper } from './form-css.helper';\nimport { BaseControl, ControlData, DependentDictionaryData, PresentationControl, PresentationControlType, SectionData, StepData } from './models/flux.model';\n\n@Component({\n  selector: 'app-origin-form',\n  templateUrl: './origin-form.component.html',\n  styleUrls: ['./origin-form.component.scss'],\n})\nexport class CollectorFormComponent implements OnChanges, OnDestroy {\n  @ViewChildren(FormlyField) formlyFields: QueryList<FormlyField>;\n  \n  //these are specific to the lib\n  @Input() configComponent: InputConfig | undefined;\n  @Input() configUuid!: string;\n  @Input() currentStepId: string;\n  //end specific to lib\n\n  @Input() appModel: FormModel;\n  @Input() signBaseUrl: string;\n  @Input() currentLanguageIso: string;\n  @Input() fillData: any;\n  @Input() env: string;\n  @Input() showDisplayMode: boolean = false;\n  @Input() showLanguageSelector: boolean = true;\n  @Input() isDemoMode: boolean = false;\n  @Input() isDebug: boolean = false;\n  @Input() appDataUuid: string;\n  @Input() blockPreviousStep: boolean;\n  @Input() dataUrlId: string;\n  @Input() noButtonsInView: boolean = false;\n  private flux: StepData[];\n  private display: DisplayModel;\n  private design: CssRules;\n  private generalData: GeneralDataModel;\n  private labels: Label[];\n  private stepDictionaryDependentIds: string[];\n  private availableLanguages: Language[];\n  private stepsSettings: StepsSettings;\n  formlyConfigUpdated = new EventEmitter<void>();\n  visibleFieldsUpdated = new EventEmitter<any>();\n  formlyUpdateAndGoNext = new EventEmitter<any>();\n  formlyGoNext = new EventEmitter<void>();\n\n  @Output() completionEvent = new EventEmitter<void>();\n\n  form = new FormGroup({});\n  formlyConfig: FormlyFieldConfig[] = [];\n  formlyAllSteps: FormlyFieldConfig[] = [];\n  activeStep = 0;\n  model: any;\n  options: FormlyFormOptions = {};\n  isLoading: boolean = true;\n\n  dictionaryMap: Map<string, DictionaryDto> = new Map();\n  dictionaryIdToUuidMap: Map<number, string> = new Map();\n  generalDataKeys = LabelKeys.appConfigEdit.generalData;\n  private fieldUnsubscribeSubjects: Subject<void>[] = [];\n  private collectorHandlerSubscriptions: Subscription = new Subscription();\n\n  // Action step execution state\n  private isExecutingActions = false;\n  private actionStepSubscriptions: Subscription = new Subscription();\n  public isSavingAfterActions = false; // Make this public so stepper can access it\n\n  // identification kyc component\n  public kycApiUrl: string;\n  public kycOrderId: string;\n  public kycToken: string;\n  public kycEnv: string;\n  public kycRedirectId: string;\n  public kycPhoneNumber: string = '';\n  public kycLangIso: string = '';\n  public kycShowCitizenship: boolean = false;\n  public kycScrollMode: boolean = false;\n  // end identification kyc component\n  public languageFlags: any[] = [\n    {\n      language: 'English',\n      code: 'en',\n      type: 'US',\n      icon: '/assets/images/flag/icon-flag-en.svg',\n    },\n    {\n      language: 'Romana',\n      code: 'ro',\n      icon: '/assets/images/flag/icon-flag-ro.svg',\n    },\n    {\n      language: 'Deutsch',\n      code: 'de',\n      icon: '/assets/images/flag/icon-flag-de.svg',\n    },\n    {\n      language: 'Français',\n      code: 'fr',\n      icon: '/assets/images/flag/icon-flag-fr.svg',\n    },\n    {\n      language: 'Italiano',\n      code: 'it',\n      icon: '/assets/images/flag/icon-flag-it.svg',\n    },\n    {\n      language: 'Español',\n      code: 'es',\n      icon: '/assets/images/flag/icon-flag-es.svg',\n    },\n  ];\n  formlyCollectingFields: FormlyFieldConfig[];\n  formlyPresentationFields: FormlyFieldConfig[];\n  controlIdsWithValues: any;\n  _self = this;\n\n  \n  constructor(\n    private service: DictionaryService,\n    private cdRef: ChangeDetectorRef,\n    private renderer: Renderer2,\n    proxy: ProxyService,\n    private labelService: LabelService,\n    private applicationDataService: ApplicationDataService,\n    private langService: LanguageService,\n    private authService: OriginFormAuthService,\n    private formsService: FormsService,\n    private configService: ConfigService,\n    private translationService: TranslationService,\n    private originFormSignalrHandlerService: OriginFormSignalrHandlerService,\n    private actionStepHandler: ActionStepHandler,\n    private scrollToErrorService: ScrollToErrorService\n  ) {\n    this.kycApiUrl = proxy.apiURL;\n    this.kycOrderId = proxy.orderID!;\n    this.kycToken = proxy.token;\n    this.kycEnv = proxy.env;\n\n    this.kycLangIso = proxy.langIso;\n    const isLoadingSub =\n      this.originFormSignalrHandlerService.isLoading$.subscribe((loading) => {\n        if (this.isLoading !== loading) {\n          this.isLoading = loading;\n        }\n      });\n    this.collectorHandlerSubscriptions.add(isLoadingSub);\n\n        const operationCompletedSub =\n      this.originFormSignalrHandlerService.operationCompleted$.subscribe(\n        async (result: OperationResult) => {\n          if (result.operationIdentifier === 'KYC_PROCESSING') {\n            if (result.success) {\n              console.log(\n                'KYC Processing successfully completed (via Handler Service):',\n                result.data\n              );\n              if (result.data) {\n                this.fillData = JSON.parse(result.data.fillData);\n                this.populateModelWithFillData(this.fillData);\n              }\n\n              this.formlyUpdateAndGoNext.emit({});\n            } else {\n              console.error(\n                'KYC Processing failed (via Handler Service):',\n                result.error\n              );\n            }\n          }\n        }\n      );\n    this.collectorHandlerSubscriptions.add(operationCompletedSub);\n\n    // Subscribe to action step execution events\n    const actionExecutingSub =\n      this.actionStepHandler.actionExecuting$.subscribe((executing) => {\n        this.isExecutingActions = executing;\n        this.isLoading = executing;\n        this.cdRef.detectChanges();\n      });\n    this.actionStepSubscriptions.add(actionExecutingSub);\n\n    const actionCompletedSub =\n      this.actionStepHandler.actionCompleted$.subscribe((result) => {\n        console.log('🎬 Action step completed:', result);\n        if (!result.success) {\n          console.error('❌ Action step failed:', result.error);\n        }\n        // Note: We don't auto-progress here as it's handled in executeActionStepsBeforeMoving\n      });\n    this.actionStepSubscriptions.add(actionCompletedSub);\n  }\n\n  async ngOnInit(): Promise<void> {\n    if (this.dataUrlId) {\n      var result = await firstValueFrom(\n        this.applicationDataService.getDataUrl(this.dataUrlId)\n      );\n      if (result) {\n        this.configUuid = result.appId;\n        this.appDataUuid = result.appDataId;\n        this.env = result.env;\n      }\n    }\n\n    if (this.appDataUuid && this.currentStepId) {\n      this.applicationDataService.setCurrentStep(\n        this.appDataUuid,\n        this.currentStepId\n      );\n    }\n\n    if (!this.appDataUuid) {\n      this.appDataUuid = Utils.generateUUID();\n    }\n\n    if (\n      this.configComponent &&\n      this.configComponent.Token &&\n      this.configComponent.RefreshToken\n    ) {\n      this.configService.updateConfigFromInput(this.configComponent);\n      await this.authService.setTokens(\n        this.configComponent.Token,\n        this.configComponent.RefreshToken\n      );\n    }\n    if (!this.availableLanguages || this.availableLanguages.length === 0) {\n      await firstValueFrom(this.langService.getLanguages()).then((list) => {\n        if (list && list.items?.length > 0) {\n          this.availableLanguages = list.items;\n        }\n      });\n    }\n    await this.loadAppData();\n    if (!this.currentLanguageIso && this.appModel) {\n      this.currentLanguageIso = this.appModel.generalData.defaultLanguage;\n    }\n    if (this.appModel) {\n      await this.initAsync();\n    }\n  }\n\n async ngOnChanges(changes: SimpleChanges): Promise<void> {\n    if (changes['configComponent'] && !changes['configComponent'].firstChange) {\n      if (\n        this.configComponent &&\n        this.configComponent.Token &&\n        this.configComponent.RefreshToken\n      ) {\n        this.configService.updateConfigFromInput(this.configComponent);\n        await this.authService.setTokens(\n          this.configComponent.Token,\n          this.configComponent.RefreshToken\n        );\n      }\n    }\n    if (\n      changes['currentLanguageIso'] &&\n      !changes['currentLanguageIso'].firstChange\n    ) {\n      this.isLoading = true;\n\n      try {\n        if (!this.availableLanguages) {\n          await firstValueFrom(this.langService.getLanguages()).then((list) => {\n            if (list && list.items?.length > 0) {\n              this.availableLanguages = list.items;\n            }\n          });\n        }\n        if (this.appDataUuid) {\n          try {\n            const appData = await this.applicationDataService.getSteps(\n              this.appDataUuid\n            );\n            if (appData && appData.fillData) {\n              this.fillData = JSON.parse(appData.fillData);\n              this.blockPreviousStep = appData.blockPreviousStep;\n              if (this.fillData.metadata.language) {\n                this.currentLanguageIso = this.fillData.metadata.language;\n              }\n            }\n          } catch (error) {\n            console.error('Error retrieving app data', error);\n          }\n        }\n        await this.initAsync();\n      } catch (error) {\n      } finally {\n        this.isLoading = false;\n      }\n    }\n  }\n\n  async loadAppData(): Promise<void> {\n    this.isLoading = true;\n    try {\n      const response: { configuration: any; fillData?: any } =\n        await firstValueFrom(\n          this.formsService.loadFormByUuid(this.configUuid, this.env)\n        );\n      this.appModel = JSON.parse(response.configuration);\n      this.fillData = response.fillData ? JSON.parse(response.fillData) : null;\n    } catch (error) {\n      console.error('Error loading form data', error);\n    } finally {\n      this.isLoading = false;\n    }\n  }\n\n  async initAsync(): Promise<void> {\n    this.unsubscribeFromAllFields();\n    await this.buildFormlyAsync();\n    await this.initializeReferenceFields(this.formlyConfig);\n    this.updateFormlyConfig();\n    this.formlyConfigUpdated.emit();\n    this.cdRef.detectChanges();\n  }\n\n  public applicationLanguages(): Language[] {\n    return this.availableLanguages?.filter((a) => {\n      return this.appModel?.generalData?.languages?.indexOf(a.iso) >= 0;\n    });\n  }\n\n  public returnFLag(language: string) {\n    return this.languageFlags.find((l) => l.code == language)?.icon;\n  }\n\n  changeLanguage($event: string) {\n    this.currentLanguageIso = $event;\n    this.applicationDataService\n      .changeLanguage(this.appDataUuid, this.currentLanguageIso)\n      .subscribe();\n    this.initAsync();\n  }\n  getLanguageName(languageIso: string): string {\n    const language = this.availableLanguages.find(\n      (lang) => lang.iso === languageIso\n    );\n    return language ? language.name : '';\n  }\n\n  private async buildFormlyAsync(): Promise<void> {\n    if (this.currentLanguageIso) {\n      await this.getLabels();\n    }\n\n    // STEP 1: Initialize flux and other properties first\n    this.flux = this.appModel.flux;\n    this.display = this.appModel.display;\n    this.design = this.appModel.generatedCss;\n    this.generalData = this.appModel.generalData;\n    this.addRenderedCss();\n\n    // STEP 2: Load ALL dictionaries upfront (now that flux is initialized)\n    await this.loadAllRequiredDictionaries();\n\n    // STEP 3: Continue with existing form building logic\n    this.formlyConfig = [];\n    this.formlyCollectingFields = [];\n    this.formlyPresentationFields = [];\n    this.model = {};\n    this.form = new FormGroup({});\n\n    if (this.fillData) {\n      this.populateControlIdsWithValueDictionary();\n    }\n\n    // Initialize model with default values if no fillData\n    if (!this.fillData) {\n      this.model = ModelPopulationHelper.applyDefaultsToModel(\n        this.flux,\n        this.dictionaryMap,\n        this.availableLanguages\n      );\n    } else {\n      this.populateModelWithFillData(this.fillData);\n      this.populateControlIdsWithValueDictionary();\n    }\n\n    this.form.patchValue(this.model);\n    await this.buildFormlyConfigAsync();\n\n    // Initialize references for default values\n    if (!this.fillData) {\n      await this.initializeReferenceFields(this.formlyConfig);\n    }\n\n    this.form.valueChanges\n      .pipe(startWith(null), pairwise())\n      .subscribe(([prev, next]: [any, any]) =>\n        this.handleFormValueChange([prev, next])\n      );\n  }\n\n  private handleFormValueChange([prev, next]: [any, any]) {\n    const currentLanguageId = Utils.findLanguageIdByIso(\n      this.availableLanguages,\n      this.currentLanguageIso\n    );\n    for (const key in next) {\n      if (next[key]?.valueTranslations) {\n        var s = JSON.stringify(next[key]);\n        var replaced = s.replace(/\"valueTranslations\":/g, '\"translations\":');\n        next[key] = JSON.parse(replaced);\n      }\n\n      const fields = this.formlyPresentationFields.filter(\n        (i) => i.props && i.props['collectionControlIdentifier'] === key\n      );\n      if (fields && fields.length > 0) {\n        fields.forEach((field) => {\n          let value = '';\n          switch (typeof next[key]) {\n            case 'boolean':\n              value = next[key] ? '&check;' : '&cross;';\n              break;\n\n            default:\n              if (next[key]?.translations) {\n                const translation = next[key].translations.find(\n                  (translation: { languageId: any }) =>\n                    translation.languageId === currentLanguageId\n                );\n                value = translation ? translation.value : null;\n              } else {\n                value = next[key];\n              }\n              break;\n          }\n          field.defaultValue = value;\n        });\n      }\n      if (this.stepDictionaryDependentIds.find((a) => a == key)) {\n        if (\n          next[key]?.id &&\n          (prev == null || prev[key]?.id !== next[key]?.id)\n        ) {\n          this.formlyConfig[0].fieldGroup = this.getFormlyFilteredSteps();\n          var filteredStepsIdentifiers = this.formlyConfig[0].fieldGroup.map(\n            (f) => f.props?.['stepId']\n          );\n          const visibleSteps = this.actionStepHandler.filterVisibleSteps(\n            this.flux,\n            filteredStepsIdentifiers\n          );\n          this.updateFormlyConfig();\n          this.visibleFieldsUpdated.emit(visibleSteps);\n          this.formlyConfigUpdated.emit();\n        }\n      }\n    }\n  }\n\n  private getLabels(): Promise<void> {\n    return new Promise((resolve) => {\n      this.labelService\n        .getLabels(this.currentLanguageIso, false)\n        .subscribe((l) => {\n          this.labels = l;\n          resolve();\n        });\n    });\n  }\n\n  private populateControlIdsWithValueDictionary() {\n    var currentLanguageId = this.getCurrentLanguageId();\n    const controlIdsWithValues = this.fillData.flux\n      .flatMap((step: { sections: { controls: any[] }[] }) =>\n        step.sections.flatMap((section: { controls: any[] }) =>\n          section.controls\n            .filter((control) => control.controlId && control.fillValue)\n            .map((control) => ({\n              controlId: control.controlId,\n              fillValue: control.fillValue,\n              fillValueId: control.fillValueId,\n            }))\n        )\n      )\n      .reduce(\n        (\n          dictionary: { [x: string]: any },\n          { controlId, fillValue, fillValueId }: any\n        ) => {\n          if (fillValueId) {\n            for (const [key, dict] of this.dictionaryMap.entries()) {\n              const value = dict.values?.find((v) => v.id == fillValueId);\n              if (value) {\n                const translation = value.valueTranslations.find(\n                  (t) => t.languageId == currentLanguageId\n                );\n                if (translation) {\n                  dictionary[controlId] = translation.value;\n                  break;\n                }\n              }\n            }\n          } else {\n            dictionary[controlId] = fillValue;\n          }\n          return dictionary;\n        },\n        {} as Record<string, any>\n      );\n    this.controlIdsWithValues = controlIdsWithValues;\n  }\n  private getCurrentLanguageId(): number {\n    const currentLanguageId = Utils.findLanguageIdByIso(\n      this.availableLanguages,\n      this.currentLanguageIso\n    );\n    return currentLanguageId;\n  }\n  private async buildFormlyConfigAsync(): Promise<void> {\n    this.stepsSettings = {\n      showCounter: this.showDisplayMode\n        ? false\n        : this.generalData.showCounterStep,\n      showLabels: this.showDisplayMode ? false : this.generalData.showNameStep,\n      showAllSteps: this.showDisplayMode\n        ? false\n        : this.generalData.showAllSteps,\n      showProgressBar:\n        this.generalData.showProgressBar &&\n          this.generalData.showAllSteps == false\n          ? true\n          : false,\n    };\n\n    this.formlyAllSteps = await this.buildFormlyFieldGroupAsync();\n    var hasDictionaryDependentSteps = this.formlyAllSteps.some(\n      (f) => f.props?.['dependentDictionary']?.isDictionaryDependent\n    );\n\n    var formlyFilteredSteps = this.getFormlyFilteredSteps();\n    var filteredStepsIdentifiers = formlyFilteredSteps.map(\n      (f) => f.props?.['stepId']\n    );\n    // Get visible steps for accurate step counting\n    const visibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux);\n    const filteredVisibleSteps = this.actionStepHandler.filterVisibleSteps(\n      this.flux,\n      filteredStepsIdentifiers\n    );\n\n    this.formlyConfig = [\n      {\n        type: 'stepper',\n        props: {\n          appDataId: this.fillData\n            ? this.fillData?.metadata?.appDataId\n            : this.appDataUuid,\n          design: this.design,\n          applicationId: this.appModel.applicationUuid,\n          flux: visibleSteps, // Pass only visible steps to stepper\n          filteredFlux: filteredVisibleSteps,\n          isDisplayMode: this.showDisplayMode,\n          fillData: this.fillData,\n          defaultLanguage: this.appModel.generalData.defaultLanguage,\n          display: this.display,\n          designConfig: {\n            buttonsVerticalPosition:\n              this.appModel.design.buttonsVerticalPosition,\n            buttonsHorizontalPosition:\n              this.appModel.design.buttonsHorizontalPosition,\n          },\n          stepsSettings: this.stepsSettings,\n          metaData: this.fillData?.metadata,\n          demoMode: this.isDemoMode,\n          isDebug: this.isDebug,\n          noButtonsInView: this.noButtonsInView,\n          blockPreviousStep: this.blockPreviousStep,\n          env: this.env,\n          hasDictionaryDependentSteps: hasDictionaryDependentSteps,\n          hasActionSteps: this.flux.some((step) =>\n            this.actionStepHandler.isActionStep(step)\n          ), // Indicate if there are action steps\n          completionEvent: () => this.onCompletion(),\n          onSelectedPageChanging: (index: number) =>\n            this.onSelectedPageChanging(index),\n          onSelectedPageChanged: (index: number) =>\n            this.onSelectedPageChanged(index),\n        },\n        fieldGroup: formlyFilteredSteps,\n      },\n    ];\n  }\n\n  private async onSelectedPageChanging(stepTransition: any): Promise<boolean> {\n    let fromIndex: number;\n    let toIndex: number;\n    let callback: () => void = () => { };\n\n    if (typeof stepTransition === 'number') {\n      toIndex = stepTransition;\n      fromIndex = this.activeStep;\n    } else {\n      fromIndex = stepTransition.from;\n      toIndex = stepTransition.to;\n      callback = stepTransition.callback || (() => { });\n    }\n\n    let actionsExecuted = false;\n\n    if (toIndex > fromIndex) {\n      console.log(\n        '➡️ Moving forward - executing action steps after current step'\n      );\n      actionsExecuted = await this.executeActionStepsAfterCurrentStep(\n        fromIndex\n      );\n    } else if (toIndex < fromIndex) {\n      console.log('⬅️ Moving backward - no action execution needed');\n    } else {\n      console.log('🔄 Staying on same step - no action execution needed');\n    }\n\n    this.activeStep = toIndex;\n\n    if (callback) {\n      callback();\n    }\n\n    return actionsExecuted;\n  }\n\n  private async executeActionStepsAfterCurrentStep(\n    currentStepIndex: number\n  ): Promise<boolean> {\n    if (this.actionStepHandler.isExecutingActions) {\n      return false;\n    }\n\n    let filteredSteps = this.flux.filter((s) => {\n      if (\n        s.dependentDictionary &&\n        s.dependentDictionary.isDictionaryDependent\n      ) {\n        const selectedValue =\n          this.model[s.dependentDictionary.dictionaryControlIdentifier]?.id;\n        if (\n          selectedValue &&\n          s.dependentDictionary.dependentValueIds.includes(selectedValue)\n        ) {\n          return true;\n        }\n        return false;\n      }\n      return true;\n    });\n\n    const actionSteps = this.actionStepHandler.getActionStepsAtIndex(\n      filteredSteps,\n      currentStepIndex\n    );\n\n    if (actionSteps.length === 0) {\n      return false;\n    }\n    try {\n      if (!this.appDataUuid) {\n        return false;\n      }\n\n      // Set the saving flag before starting actions\n      this.isSavingAfterActions = true;\n      this.isLoading = true;\n\n      const result = await this.actionStepHandler.executeActionSteps(\n        actionSteps,\n        this.appDataUuid,\n        (step) => {\n          const loadingMessage = Utils.findTranslationInfo(\n            'loadingMessageTranslations',\n            step.translations,\n            this.currentLanguageIso\n          );\n          this.loadingMessage = loadingMessage || null;\n        }\n      );\n\n      if (result.success) {\n        console.log('✅ Action steps executed successfully');\n        // Keep loading state true - it will be cleared after saveAppDataStep completes\n        return true;\n      } else {\n        console.error('❌ Action steps execution failed:', result.error);\n        this.isSavingAfterActions = false;\n        this.isLoading = false;\n        return false;\n      }\n    } catch (error) {\n      console.error('❌ Error executing action steps:', error);\n      this.isSavingAfterActions = false;\n      this.isLoading = false;\n      return false;\n    }\n  }\n\n  private onSelectedPageChanged(index: number) {\n    if (this.formlyConfig[0].fieldGroup) {\n      var selectedPage = this.formlyConfig[0].fieldGroup[index];\n      this.setPresentationControlValuesRecursively(selectedPage);\n    }\n  }\n\n  private setPresentationControlValuesRecursively(fc?: any) {\n    fc?.fieldGroup?.forEach((fg: any) => {\n      if (fg.props && fg.props['isDisplayMode'] === true) {\n        var methodFieldId = fg.props['apiMethodFieldId'];\n        if (methodFieldId) {\n          const val = this.findInApiCallsResponses(methodFieldId);\n          fg.defaultValue = val;\n        } else {\n          var associatedControlId = fg.props['collectionControlIdentifier'];\n          if (associatedControlId) {\n            const found =\n              this.findControlInFillDataControls(associatedControlId);\n            if (found) {\n              if (found.fillValueId) {\n                const currentLanguageId = this.getCurrentLanguageId();\n                for (const [key, dict] of this.dictionaryMap.entries()) {\n                  const value = dict.values?.find(\n                    (v) => v.id == found.fillValueId\n                  );\n                  if (value) {\n                    const translation = value.valueTranslations.find(\n                      (t) => t.languageId == currentLanguageId\n                    );\n                    if (translation) {\n                      fg.defaultValue = translation.value;\n                      break;\n                    }\n                  }\n                }\n              } else {\n                fg.defaultValue = found.fillValue;\n              }\n            } else {\n              const val = this.findInApiCallsResponses(associatedControlId);\n              fg.defaultValue = val;\n            }\n          }\n        }\n      } else {\n        this.setPresentationControlValuesRecursively(fg);\n      }\n      if (fg.props['cdr']) {\n        fg.props['cdr'].detectChanges();\n      }\n    });\n  }\n\n  private findControlInFillDataControls(controlId: string): any {\n    let controlData: any = undefined;\n    if (this.fillData) {\n      this.fillData.flux?.forEach((f: any) => {\n        if (!controlData) {\n          f.sections?.forEach((s: any) => {\n            if (!controlData) {\n              controlData = s.controls?.find(\n                (c: any) => c.controlId === controlId\n              );\n              if (controlData) {\n                return controlData;\n              }\n            }\n          });\n        }\n      });\n    }\n    return controlData;\n  }\n\n  private findInApiCallsResponses(fieldId: string): any {\n    let foundValue: any = undefined;\n    if (this.fillData) {\n      this.fillData.APICalls?.forEach((api: any) => {\n        if (!foundValue) {\n          api.Methods?.forEach((m: any) => {\n            if (!foundValue) {\n              const found = m.Fields?.[fieldId];\n              if (found) {\n                foundValue = found;\n              }\n            }\n          });\n        }\n      });\n    }\n    return foundValue;\n  }\n\n  private getFormlyFilteredSteps() {\n    let steps = this.formlyAllSteps.filter((s) => {\n      if (s.props && s.props['dependentDictionary']) {\n        const depDict = s.props[\n          'dependentDictionary'\n        ] as DependentDictionaryData;\n        if (depDict && depDict.isDictionaryDependent) {\n          const selectedValue =\n            this.model[depDict.dictionaryControlIdentifier]?.id;\n          if (\n            selectedValue &&\n            depDict.dependentValueIds.includes(selectedValue)\n          ) {\n            return true;\n          }\n          return false;\n        }\n      }\n      return true;\n    });\n\n    return steps;\n  }\n\n  private async buildFormlyFieldGroupAsync(): Promise<FormlyFieldConfig[]> {\n    this.stepDictionaryDependentIds = [];\n    if (this.showDisplayMode) {\n      const step = await this.buidDisplayStep();\n      return Promise.resolve([step]);\n    } else {\n      // Filter out action steps from visible steps\n      const visibleSteps = this.actionStepHandler.filterVisibleSteps(this.flux);\n      return await Promise.all(\n        visibleSteps.map((step) => {\n          return this.buildFormlyFieldConfigAsync(step);\n        }) ?? []\n      );\n    }\n  }\n\n  private async buildFormlyFieldConfigAsync(\n    step: StepData\n  ): Promise<FormlyFieldConfig> {\n    let stepFormlyConfig: FormlyFieldConfig = {};\n\n    if (step.type !== FluxType.Custom && step.type !== FluxType.Final) {\n      stepFormlyConfig = await this.buildSystemFieldFormlyConfig(step);\n    } else {\n      stepFormlyConfig = {\n        props: {\n          label: step.name,\n          description: step.name,\n          buttons: this.constructButtons(step.buttons),\n          dependentDictionary: step.dependentDictionary,\n          stepId: step.identifier,\n        },\n        fieldGroup: await this.buildSectionsFieldGroupAsync(\n          step,\n          step.sections\n        ),\n      };\n\n      if (step.translations) {\n        stepFormlyConfig.props!['label'] = Utils.findTranslationInfo(\n          'name',\n          step.translations,\n          this.currentLanguageIso\n        );\n        stepFormlyConfig.props!['description'] = Utils.findTranslationInfo(\n          'description',\n          step.translations,\n          this.currentLanguageIso\n        );\n      }\n    }\n\n    if (stepFormlyConfig && stepFormlyConfig.props) {\n      this.setStepBaseProps(step, stepFormlyConfig);\n    }\n    if (step.dependentDictionary?.isDictionaryDependent) {\n      this.stepDictionaryDependentIds.push(\n        step.dependentDictionary.dictionaryControlIdentifier\n      );\n    }\n    return stepFormlyConfig;\n  }\n\n  triggerComponentUpdate(controlId: string, value: any): void {\n    this.setFormlyFieldValue(this.formlyAllSteps, controlId, value);\n  }\n\n  setFormlyFieldValue(\n    fields: FormlyFieldConfig[] | undefined,\n    key: string,\n    value: any\n  ): boolean {\n    if (!fields) return false;\n\n    for (const field of fields) {\n      if (field.key === key) {\n        if (field.formControl) {\n          field.formControl.setValue(value, { emitEvent: true });\n          return true;\n        }\n      }\n\n      if (field.fieldGroup && Array.isArray(field.fieldGroup)) {\n        const found = this.setFormlyFieldValue(field.fieldGroup, key, value);\n        if (found) return true;\n      }\n    }\n\n    return false;\n  }\n\n  private async buildSystemFieldFormlyConfig(\n    step: StepData\n  ): Promise<FormlyFieldConfig> {\n    const formlyConfig: FormlyFieldConfig = {\n      props: {\n        label: step.name,\n        buttons: this.constructButtons(step.buttons),\n        fluxType: step.type,\n      },\n      fieldGroup: [],\n    };\n\n    this.setStepBaseProps(step, formlyConfig);\n    var fieldConfig = this.createFormlySystemFieldConfig(step);\n\n    if (fieldConfig) {\n      if (step.translations) {\n        let labels: any = {};\n        step.translations.forEach((tr: TranslationInfo) => {\n          labels[tr.name] = Utils.findTranslation(\n            tr.values,\n            this.currentLanguageIso\n          );\n        });\n        fieldConfig.props!['labels'] = labels;\n        fieldConfig.props!['name'] = Utils.findTranslationInfo(\n          'name',\n          step.translations,\n          this.currentLanguageIso\n        );\n        fieldConfig.props!['description'] = Utils.findTranslationInfo(\n          'description',\n          step.translations,\n          this.currentLanguageIso\n        );\n        formlyConfig.props!['label'] = Utils.findTranslationInfo(\n          'name',\n          step.translations,\n          this.currentLanguageIso\n        );\n        formlyConfig.props!['description'] = Utils.findTranslationInfo(\n          'description',\n          step.translations,\n          this.currentLanguageIso\n        );\n      }\n      fieldConfig.props!['stepsSettings'] = this.stepsSettings;\n      formlyConfig.fieldGroup!.push(fieldConfig);\n    }\n\n    return formlyConfig;\n  }\n\n  private setStepBaseProps(step: StepData, formlyConfig: FormlyFieldConfig) {\n    if (formlyConfig.props) {\n      formlyConfig.props['name'] = step.name;\n      formlyConfig.props['fluxType'] = step.type;\n      formlyConfig.props['stepId'] = step.identifier;\n      formlyConfig.props['isVisible'] = step.isVisible;\n      formlyConfig.props['dependentDictionary'] = step.dependentDictionary;\n    }\n  }\n\n  private CreateSignFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-sign-component',\n      props: {\n        appDataId: this.appDataUuid,\n        stepData: step,\n        design: this.design,\n        env: this.env,\n        flux: this.flux,\n        parentForm: this.form,\n        getModel: () => this.model,\n        event: async (event: any) => {\n          if (event === 'success') {\n            await this.stepperGoNextAsync();\n          }\n        },\n      },\n    };\n  }\n\n  private CreateDownloadDocsFieldConfig(\n    controlData: BaseControl\n  ): FormlyFieldConfig {\n    return {\n      type: 'formly-download-documents-component',\n      props: {\n        appId: this.appModel.applicationUuid,\n        appDataId: this.appDataUuid,\n        controlData: controlData,\n        env: this.env,\n        documentsData: this.appModel.documents,\n        langIso: this.currentLanguageIso,\n      },\n    };\n  }\n\n  private CreateViewDocsFieldConfig(\n    controlData: BaseControl\n  ): FormlyFieldConfig {\n    return {\n      type: 'formly-view-documents-component',\n      props: {\n        appId: this.appModel.applicationUuid,\n        appDataId: this.appDataUuid,\n        controlData: controlData,\n        env: this.env,\n        documentsData: this.appModel.documents,\n        langIso: this.currentLanguageIso,\n      },\n    };\n  }\n\n  private CreateUploadDocsFieldConfig(\n    controlData: BaseControl\n  ): FormlyFieldConfig {\n    return {\n      type: 'formly-upload-documents-component',\n      props: {\n        appId: this.appModel.applicationUuid,\n        appDataId: this.appDataUuid,\n        controlData: controlData,\n        env: this.env,\n        documentsData: this.appModel.documents,\n        langIso: this.currentLanguageIso,\n      },\n    };\n  }\n\n  private CreateGenerateDocsFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-generate-documents-component',\n      props: {\n        appId: this.appModel.applicationUuid,\n        appDataId: this.appDataUuid,\n        stepData: step,\n        documentsData: this.appModel.documents,\n        langIso: this.currentLanguageIso,\n        event: async (event: any) => {\n          if (event === 'success') {\n            await this.stepperGoNextAsync();\n          }\n        },\n      },\n    };\n  }\n\n  async stepperGoNextAsync() {\n    const stepperComponent = this.formlyConfig[0].props!['component'];\n    if (stepperComponent && stepperComponent.navigateNextAsync) {\n      await stepperComponent.navigateNextAsync();\n    }\n  }\n\n  private CreateEnrollCardFieldConfig(step: StepData): FormlyFieldConfig {\n    let labels: any = {};\n    Object.keys(step.config).forEach((key) => {\n      if (key.endsWith('Label')) {\n        labels[key] =\n          step?.config[key]?.find(\n            (i: { languageIso: string }) =>\n              i.languageIso === this.currentLanguageIso\n          )?.value ?? '';\n      }\n    });\n    return {\n      type: 'formly-enrol-card-component',\n      props: {\n        appId: this.appModel.applicationUuid,\n        appDataId: this.appDataUuid,\n        dataUrlId: this.dataUrlId,\n        stepData: step,\n        labels: labels,\n        langIso: this.currentLanguageIso,\n      },\n    };\n  }\n  private CreateIdScanFieldConfig(step: StepData): FormlyFieldConfig {\n    let errorMessages: any = {};\n\n    if (step.errorsTranslations) {\n      step.errorsTranslations.forEach((error: any) => {\n        errorMessages[error.code] = Utils.findTranslation(\n          error.translations,\n          this.currentLanguageIso\n        );\n      });\n    }\n\n    return {\n      type: 'formly-scan-id',\n      props: {\n        config: step.config,\n        stepType: step.type,\n        stepId: step.identifier,\n        appDataId: this.appDataUuid || Utils.generateUUID(),\n        appId: this.appModel.applicationUuid,\n        errorMessages: errorMessages,\n        event: (event: any) => this.onIdScanCompleted(event, step),\n      },\n    };\n  }\n\n  private CreateKycFieldConfig(step: StepData): FormlyFieldConfig {\n    const loadingMsgTranslations = step.translations?.find(\n      (t: any) => t.name === 'loadingMessageTranslations'\n    );\n\n    const translatedLoadingMessage =\n      loadingMsgTranslations?.values?.find(\n        (v: any) => v.languageIso === this.currentLanguageIso\n      )?.value || '';\n\n    return {\n      type: 'formly-identification-component',\n      props: {\n        token: this.kycToken,\n        api_url: this.kycApiUrl,\n        appDataId: this.appDataUuid,\n        env: 'QA', // Consider making this dynamic if needed\n        redirect_id: this.kycRedirectId,\n        phone_number: '',\n        lang_iso: this.kycLangIso,\n        show_citizenship_selector: this.kycShowCitizenship,\n        scroll_mode: this.kycScrollMode,\n        maxRetries: step.config?.maxKycRetries ?? 3,\n        loadingMessage: translatedLoadingMessage,\n        ectCompleted: async () => {\n          this.loadingMessage = translatedLoadingMessage;\n          await this.originFormSignalrHandlerService.initiateKycProcessing(\n            this.appDataUuid\n          );\n        },\n      },\n    };\n  }\n\n  private CreatePhoneEmailFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-validate-contact-info',\n      props: {\n        stepData: step,\n        appDataId: this.appDataUuid,\n        design: this.design,\n        event: async (event: any) => {\n          if (event === 'success') {\n            await this.stepperGoNextAsync();\n          }\n        },\n      },\n    };\n  }\n\n  private CreateViewOfferFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-view-offers',\n      props: {\n        appDataId: this.appDataUuid,\n        stepData: step,\n        env: this.env,\n        appModel: this.appModel,\n        langIso: this.currentLanguageIso,\n        event: (event: any) => this.onOfferSelected(event, step),\n      },\n    };\n  }\n\n  private CreatePauseFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-field-pause',\n      props: {\n        identifier: step.identifier,\n        config: step.config,\n        appDataId: this.appDataUuid,\n        stepData: step,\n        env: this.env,\n        appModel: this.appModel,\n        langIso: this.currentLanguageIso,\n      },\n    };\n  }\n\n  private CreateOpenBankingFieldConfig(step: StepData): FormlyFieldConfig {\n    // Pass the full step data which includes all translations\n    // The component will extract what it needs based on current language\n    return {\n      type: 'formly-open-banking',\n      props: {\n        identifier: step.identifier,\n        config: step.config,\n        appDataId: this.appDataUuid,\n        stepData: step, // This contains the full translations array\n        env: this.env,\n        appModel: this.appModel,\n        langIso: this.currentLanguageIso,\n        labels: {\n          initialMessage: Utils.findTranslation(\n            step.config?.initialMessageTranslations || [],\n            this.currentLanguageIso\n          ),\n          waitingMessage: Utils.findTranslation(\n            step.config?.waitingMessageTranslations || [],\n            this.currentLanguageIso\n          ),\n          consentErrorMessage: Utils.findTranslation(\n            step.config?.consentErrorMessageTranslations || [],\n            this.currentLanguageIso\n          ),\n          completionMessage: Utils.findTranslation(\n            step.config?.completionMessageTranslations || [],\n            this.currentLanguageIso\n          ),\n          retryButtonLabel: Utils.findTranslation(\n            step.config?.retryButtonLabelTranslations || [],\n            this.currentLanguageIso\n          ),\n        },\n        event: (event: any) => this.onOpenBankingEvent(event, step),\n      },\n    };\n  }\n\n  private CreateStatusFieldConfig(step: StepData): FormlyFieldConfig {\n    return {\n      type: 'formly-status',\n      props: {\n        config: step.config,\n        stepData: step,\n        appDataId: this.appDataUuid,\n        appId: this.appModel.applicationUuid,\n      },\n    };\n  }\n\n  private createFormlySystemFieldConfig(\n    step: StepData\n  ): FormlyFieldConfig | undefined {\n    switch (step.type) {\n      case FluxType.Kyc:\n        {\n          return this.CreateKycFieldConfig(step);\n        }\n        break;\n      case FluxType.Email:\n      case FluxType.Phone: {\n        return this.CreatePhoneEmailFieldConfig(step);\n      }\n      case FluxType.Action: {\n        // Action steps are now handled automatically by ActionStepHandler\n        // They should not appear as visible formly components\n        return undefined;\n      }\n      case FluxType.IdScan: {\n        return this.CreateIdScanFieldConfig(step);\n      }\n      case FluxType.GenerateDocument: {\n        return this.CreateGenerateDocsFieldConfig(step);\n      }\n      case FluxType.Sign: {\n        return this.CreateSignFieldConfig(step);\n      }\n      case FluxType.ViewOffer: {\n        return this.CreateViewOfferFieldConfig(step);\n      }\n      case FluxType.Status: {\n        return this.CreateStatusFieldConfig(step);\n      }\n      case FluxType.EUPLATESC: {\n        return this.CreateEnrollCardFieldConfig(step);\n      }\n      case FluxType.NETOPIA: {\n        return this.CreateEnrollCardFieldConfig(step);\n      }\n      case FluxType.Pause: {\n        return this.CreatePauseFieldConfig(step);\n      }\n      case FluxType.OpenBanking: {\n        return this.CreateOpenBankingFieldConfig(step);\n      }\n    }\n    return undefined;\n  }\n\n  onOfferSelected(offerId: any, step: StepData) {\n    this.formlyUpdateAndGoNext.emit({ selectedOfferId: offerId });\n  }\n\n  private onSignEvent(event: any, step: StepData) {\n    console.log('Sign event received:', event);\n    this.updateStepButtonState(step);\n  }\n\n  private onOpenBankingEvent(event: any, step: StepData) {\n    console.log('OpenBanking event received:', event);\n    if (event === 'success') {\n      // Open Banking flow completed successfully\n      this.updateStepButtonState(step);\n      // Auto-proceed to next step\n      this.formlyUpdateAndGoNext.emit({});\n    }\n  }\n\n  private onIdScanCompleted(event: any, step: StepData) {\n    console.log('Sign event received:', event);\n    const fillData = JSON.parse(event.fillData);\n    const stepFillData = fillData.flux.find(\n      (s: { stepId: string }) => s.stepId == step.identifier\n    );\n    stepFillData.sections.forEach(\n      (s: {\n        controls: {\n          controlId: string | undefined;\n          fillValue: string | undefined;\n        }[];\n      }) => {\n        s.controls.forEach(\n          (c: {\n            controlId: string | undefined;\n            fillValue: string | undefined;\n          }) => {\n            if (c.controlId) {\n              const value = {\n                [c.controlId]: {\n                  value: c.fillValue,\n                },\n              };\n\n              if (this.form.contains(c.controlId)) {\n                this.form.patchValue(value);\n              } else {\n                this.form.addControl(c.controlId, new FormControl(c.fillValue));\n              }\n            }\n          }\n        );\n      }\n    );\n\n    this.updateStepButtonState(step);\n  }\n\n  updateStepButtonState(step: StepData) {\n    let formlyStepField = this.formlyConfig[0].fieldGroup?.find((field) =>\n      field.fieldGroup?.find((f) => f.props?.['stepId'] === step.identifier)\n    );\n\n    if (!formlyStepField) {\n      formlyStepField = this.formlyConfig[0].fieldGroup?.find(\n        (field) => field.props?.['stepId'] === step.identifier\n      );\n    }\n\n    if (formlyStepField) {\n      formlyStepField.props = {\n        ...formlyStepField.props,\n        buttonsDisabled: false,\n      };\n      this.updateFormlyConfig();\n      this.formlyConfigUpdated.emit();\n    }\n  }\n\n  private addRenderedCss() {\n    const styleString = FormCssHelper.convertToStyleString(\n      this.design,\n      this.showDisplayMode\n    );\n\n    const styleElement = this.renderer.createElement('style');\n    styleElement.id = 'rendered-css';\n    const rendEl = document.getElementById('rendered-css');\n    if (rendEl) {\n      this.renderer.removeChild(document.body, rendEl);\n    }\n    this.renderer.appendChild(\n      styleElement,\n      this.renderer.createText(Utils.removeNewLines(styleString))\n    );\n    this.renderer.appendChild(document.body, styleElement);\n  }\n\n  async buildSectionsFieldGroupAsync(\n    step: StepData | undefined,\n    sections: SectionData[]\n  ): Promise<FormlyFieldConfig[]> {\n    const stepSections: FormlyFieldConfig[] = [];\n\n    for (let index = 0; sections && index < sections.length; index++) {\n      const section = sections[index];\n      let separatorFormlyConfig: any = {};\n      if (section.showSectionTitle) {\n        separatorFormlyConfig = {\n          type: 'separator',\n          props: {\n            title:\n              section.translations?.find(\n                (t: any) => t.languageIso === this.currentLanguageIso\n              )?.value ?? '',\n\n            design: this.design,\n          },\n        };\n      }\n\n      if (section.showSectionSeparator) {\n        separatorFormlyConfig = {\n          ...separatorFormlyConfig,\n          type: 'separator',\n          props: {\n            ...separatorFormlyConfig.props,\n            showSeparator: section.showSectionSeparator,\n          },\n        };\n      }\n\n      if (section.dependentDictionary) {\n        this.attachToDependentDictionaryIfNecessary(\n          section.dependentDictionary,\n          separatorFormlyConfig\n        );\n      }\n      stepSections.push(separatorFormlyConfig);\n\n      const sectionFormlyConfig: FormlyFieldConfig = {\n        type: 'custom-section',\n        props: {\n          label: section.title,\n          description:\n            section.translations?.find(\n              (t: any) => t.languageIso === this.currentLanguageIso\n            )?.value ?? '',\n          design: this.design,\n        },\n        fieldGroup: await this.buildControlsFieldGroupAsync(\n          step,\n          section.controls || [],\n          section.presentationControls || []\n        ),\n        fieldGroupClassName: 'display-flex',\n      };\n      if (section.dependentDictionary) {\n        this.attachToDependentDictionaryIfNecessary(\n          section.dependentDictionary,\n          sectionFormlyConfig\n        );\n      }\n\n      stepSections.push(sectionFormlyConfig);\n    }\n\n    return stepSections;\n  }\n\n  async buidDisplayStep(): Promise<FormlyFieldConfig> {\n    let stepFormlyConfig: FormlyFieldConfig = {};\n    if (this.display?.sections?.length > 0) {\n      stepFormlyConfig = {\n        props: {\n          // label: step.name,\n          // buttons: this.constructButtons(step.buttons),\n          //  dependentDictionary: step.dependentDictionary,\n        },\n        fieldGroup: await this.buildSectionsFieldGroupAsync(\n          undefined,\n          this.display.sections\n        ),\n      };\n    }\n    return stepFormlyConfig;\n  }\n\n  addNewRowToFormFieldsIfNecessary(\n    fieldGroup: FormlyFieldConfig[],\n    newRow: FormlyFieldConfig\n  ) {\n    if (newRow.fieldGroup && newRow.fieldGroup.length > 0) {\n      this.calculateFormFieldsWidth(newRow.fieldGroup);\n      fieldGroup.push(newRow);\n    }\n  }\n\n  calculateFormFieldsWidth(formFields: FormlyFieldConfig[]) {\n    const colWidthPerItem = 12 / formFields.length;\n    formFields.forEach((f) => {\n      f.className = 'col-' + colWidthPerItem;\n    });\n  }\n\n  getPercentageClassName(percentageDimension: number): string {\n    const totalColumns = 12; // 12-column grid\n    const span = Math.round((percentageDimension / 100) * totalColumns);\n    const className = `percentage-width-${span}`;\n\n    if (!document.getElementById(className)) {\n      const style = document.createElement('style');\n      style.type = 'text/css';\n      style.id = className;\n      style.innerHTML = `\n        .${className} {\n          grid-column: span ${span};\n        }\n      `;\n      document.head.appendChild(style);\n    }\n    return className;\n  }\n\n  createFillerControl(span: number): FormlyFieldConfig {\n    return {\n      type: 'row-filler',\n      className: `percentage-width-${span}`,\n      props: {\n        label: '',\n        disabled: true,\n        hide: true,\n      },\n    };\n  }\n\n  private async buildControlsFieldGroupAsync(\n    step: StepData | undefined,\n    controls: ControlData[],\n    presentationControls: PresentationControl[]\n  ): Promise<FormlyFieldConfig[]> {\n    const result: FormlyFieldConfig[] = [];\n    let rowItems: (ControlData | PresentationControl)[] = [];\n    controls = controls.filter((c) => !c.isOnlyForConfig);\n\n    // Filter out controls that are incomplete\n    controls = controls.filter((c) => {\n      // Skip controls that are missing essential data\n      if (\n        c.type === StepControlType.Dictionary &&\n        !c.specificControlData?.dictionaryUUID\n      )\n        return false;\n      return true;\n    });\n\n    const processRow = async (\n      items: (ControlData | PresentationControl)[]\n    ) => {\n      const fields: FormlyFieldConfig[] = [];\n      const total = 12;\n      const built: FormlyFieldConfig[] = [];\n      const auto: {\n        c: ControlData | PresentationControl;\n        f: FormlyFieldConfig;\n      }[] = [];\n      let used = 0;\n      for (const i of items) {\n        if ('collectionControlIdentifier' in i === true) {\n          built.push(\n            await this.buildPresentationFormFieldAsync(\n              step,\n              i as PresentationControl\n            )\n          );\n        } else if ('apiMethodId' in i === true) {\n          built.push(\n            await this.buildApiMethodFormFieldAsync(\n              step,\n              i as PresentationControl\n            )\n          );\n        } else {\n          built.push(await this.buildFormFieldAsync(step, i as ControlData));\n        }\n      }\n      for (let i = 0; i < items.length; i++) {\n        const c = items[i];\n        const f = built[i];\n        if (c.dimensionType === DimensionType.Percentage) {\n          if (c.autoDimension) {\n            auto.push({ c, f });\n          } else {\n            const s = Math.round((c.dimension / 100) * total);\n            used += s;\n            const percentageClass = this.getPercentageClassName(c.dimension);\n            f.className = `${f.className} ${percentageClass}`;\n          }\n        } else if (c.dimensionType === DimensionType.Pixels) {\n          const s = Math.round((c.dimension / window.innerWidth) * total);\n          used += s;\n          const percentageClass = this.getPercentageClassName(\n            (s / total) * 100\n          );\n          f.className = `${f.className} ${percentageClass}`;\n        } else if (c.autoDimension) {\n          auto.push({ c, f });\n        } else {\n          used += 1;\n          const percentageClass = this.getPercentageClassName(\n            (1 / total) * 100\n          );\n          f.className = `${f.className} ${percentageClass}`;\n        }\n      }\n      const rem = total - used;\n      if (auto.length > 0) {\n        const share = Math.max(Math.floor(rem / auto.length), 1);\n        for (const a of auto) {\n          const percentageClass = this.getPercentageClassName(\n            (share / total) * 100\n          );\n          a.f.className = `${a.f.className} ${percentageClass}`;\n        }\n      }\n      fields.push(...built);\n      return fields;\n    };\n    for (const c of [...controls, ...presentationControls]) {\n      if (\n        ('type' in c && c.type === StepControlType.NewRow) ||\n        c.type == PresentationControlType.NewRow\n      ) {\n        if (rowItems.length > 0) {\n          result.push(...(await processRow(rowItems)));\n          rowItems = [];\n        }\n      } else {\n        rowItems.push(c);\n      }\n    }\n    if (rowItems.length > 0) {\n      result.push(...(await processRow(rowItems)));\n    }\n    return result;\n  }\n\n  getPixelClassName(pixelDimension: number): string {\n    const className = `pixel-width-${pixelDimension}`;\n    if (!document.getElementById(className)) {\n      const style = document.createElement('style');\n      style.type = 'text/css';\n      style.id = className;\n      style.innerHTML = `\n        .${className} {\n          width: ${pixelDimension}px;\n        }\n      `;\n      document.head.appendChild(style);\n    }\n    return className;\n  }\n\n  async buildFormFieldAsync(\n    step: StepData | undefined,\n    control: ControlData\n  ): Promise<FormlyFieldConfig> {\n    let initialType = 'input'; // Default type\n    let componentStyleKey = `.component-text-field`; // Default style for text input\n    const baseStyle = this.design[`.font-${initialType}`] || {};\n    const controlStyleString =\n      this.styleObjectToStringExceptBackground(baseStyle);\n    let pattern = '';\n    if (control.specificControlData?.allowedCharacters) {\n      try {\n        pattern = new RegExp(control.specificControlData.allowedCharacters)\n          .source;\n      } catch (e) {\n        console.error('incorrect regex pattern', e);\n      }\n    }\n\n    const componentsToExcludeFromStyle = [\n      '.component-text-field',\n      '.component-checkbox',\n      '.component-radio',\n      '.component-date',\n      '.component-data',\n    ];\n    let formlyConfig = this.getDefaultFormlyFieldConfig(\n      control,\n      initialType,\n      pattern,\n      componentStyleKey,\n      componentsToExcludeFromStyle\n    );\n    //control.specificControlData.type === 3  is email\n    if (control.specificControlData?.type === 3) {\n      this.addValidators(formlyConfig, control);\n    }\n\n    if (control.specificControlData?.isApiValidation) {\n      this.addApiValidators(formlyConfig, control);\n    }\n\n    switch (control.type) {\n      case StepControlType.ManualInput: // Text\n        var subType = control.specificControlData\n          ?.type as ManualInputControlType;\n        switch (subType) {\n          case ManualInputControlType.Numeric:\n            formlyConfig.type = 'number';\n\n            break;\n          case ManualInputControlType.Email:\n          case ManualInputControlType.Text:\n          case ManualInputControlType.Phone:\n            formlyConfig.type = 'input';\n            break;\n          case ManualInputControlType.TextArea:\n            formlyConfig.type = 'input';\n            formlyConfig.props!['autosize'] = false;\n            componentStyleKey = '.component-text-field';\n            break;\n          case ManualInputControlType.DateTime:\n            formlyConfig.type = 'datepicker';\n            formlyConfig.props = {\n              readonly: true,\n            };\n            componentStyleKey = '.component-date';\n            break;\n          default:\n            formlyConfig.type = 'input';\n            componentStyleKey = '.component-text-field';\n            break;\n        }\n        break;\n      case StepControlType.Paragraph: // Paragraph\n        formlyConfig.type = 'formly-paragraph';\n        componentStyleKey = '.component-text-field';\n\n        const translatedDescription =\n          control.specificControlData?.descriptionTranslations?.find(\n            (d: { languageIso: string }) =>\n              d.languageIso === this.currentLanguageIso\n          )?.value || '';\n        formlyConfig.defaultValue = translatedDescription;\n\n        break;\n      case StepControlType.CheckBox: // Checkbox\n        formlyConfig.type = 'formly-checkbox';\n        componentStyleKey = '.component-checkbox';\n        var checked = control.specificControlData?.checked ?? false;\n        formlyConfig.props!['checked'] = checked;\n        break;\n      case StepControlType.Dictionary: // Dictionary (dropdown)\n        componentStyleKey =\n          control.specificControlData.showAsRadioButtonsList === true\n            ? '.component-radio'\n            : '.component-data';\n        await this.constructDictionary(control, formlyConfig);\n        break;\n      case StepControlType.Buttons:\n        formlyConfig.type = '';\n        break;\n      case StepControlType.FluxInfo:\n        formlyConfig.type = '';\n        break;\n      case StepControlType.DownloadDocuments:\n        formlyConfig = this.CreateDownloadDocsFieldConfig(control);\n        break;\n      case StepControlType.ViewDocuments:\n        formlyConfig = this.CreateViewDocsFieldConfig(control);\n        break;\n      case StepControlType.UploadDocuments:\n        formlyConfig = this.CreateUploadDocsFieldConfig(control);\n        break;\n      case StepControlType.NewRow: // New Row\n        formlyConfig.type = '';\n        break;\n      default:\n        formlyConfig.type = 'input';\n        componentStyleKey = '.component-text-field';\n    }\n    formlyConfig.className = componentStyleKey.substring(1);\n\n    if (!componentsToExcludeFromStyle.find((c) => c === componentStyleKey)) {\n      if (this.design[componentStyleKey]) {\n        formlyConfig.props!.attributes!['style'] +=\n          ';' +\n          this.styleObjectToStringExceptBackground(\n            this.design[componentStyleKey]\n          );\n      }\n\n      // Apply label styles\n      const labelStyleKey = `${componentStyleKey}-label`;\n      if (this.design[labelStyleKey]) {\n        formlyConfig.props!.attributes!['style'] +=\n          ';' +\n          this.styleObjectToStringExceptBackground(\n            this.design[componentStyleKey]\n          );\n      }\n    }\n    if (control.dependentDictionary) {\n      this.attachToDependentDictionaryIfNecessary(\n        control.dependentDictionary,\n        formlyConfig\n      );\n    }\n\n    let translatedTitle = control.translations?.find(\n      (d: { languageIso: string }) => d.languageIso === this.currentLanguageIso\n    )?.value;\n    if (!translatedTitle) {\n      translatedTitle = control.title;\n    }\n    formlyConfig.props!['label'] = translatedTitle;\n\n    this.formlyCollectingFields.push(formlyConfig);\n\n    return formlyConfig;\n  }\n\n  addValidators(formlyConfig: FormlyFieldConfig, control: ControlData) {\n    var emailErrorLabel = this.flux?.find(\n      (f) => f?.config?.componentCollected === control?.identifier\n    )?.config?.emailErrorLabel;\n    var emailErrorLabelValue = '';\n    if (emailErrorLabel != null && Array.isArray(emailErrorLabel)) {\n      emailErrorLabelValue =\n        (emailErrorLabel as LabelInfo[]).find(\n          (l) => l.languageIso === this.currentLanguageIso\n        )?.value ?? '';\n    }\n\n    formlyConfig.validators = {\n      emailValid: {\n        expression: (cont: AbstractControl) => {\n          const value = cont.value;\n          const emailPattern = new RegExp(\n            '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$'\n          );\n          if (value && !emailPattern.test(value)) {\n            cont.setErrors({ invalidEmail: true });\n            return false;\n          }\n          return true;\n        },\n        message: emailErrorLabelValue,\n      },\n    };\n  }\n\n  addApiValidators(formlyConfig: FormlyFieldConfig, control: ControlData) {\n    formlyConfig.asyncValidators = {\n      validateThroughApi: {\n        expression: (cont: AbstractControl) => {\n          return (\n            cont.valueChanges.pipe(\n              debounceTime(500),\n              switchMap(() => {\n                const apiValidationMethod =\n                  control.specificControlData.apiValidationMethod;\n\n                const bodyValue = this.appModel.partners\n                  .flatMap((p) => p.partnerSettings.partnerMethodsApi)\n                  .find((p) => p.methodId === apiValidationMethod)\n                  ?.bodyConfiguration.bodyMapFields;\n\n                const fieldMap: { [key: string]: string } =\n                  bodyValue?.reduce((acc: { [key: string]: string }, f) => {\n                    if (f.fluxFieldId === control.identifier) {\n                      acc[f.partnerField] = cont.value || '';\n                    } else {\n                      acc[f.partnerField] = '';\n                    }\n                    return acc;\n                  }, {}) || {};\n\n                const dataRequest: ApiValidateRequest = {\n                  appId: this.appModel.applicationId,\n                  apiId: apiValidationMethod,\n                  data: JSON.stringify(fieldMap),\n                };\n\n                return this.validateMethodApi(dataRequest).pipe(\n                  catchError(() => of(false))\n                );\n              })\n            ) || 'ssssssssssssssss'\n          );\n        },\n        message: 'Validation failed.',\n      },\n    };\n  }\n\n  getDefaultFormlyFieldConfig(\n    control: ControlData,\n    type: string,\n    pattern: string,\n    componentStyleKey: string,\n    componentsToExcludeFromStyle: string[]\n  ): FormlyFieldConfig {\n    const currentLanguageId = Utils.findLanguageIdByIso(\n      this.availableLanguages,\n      this.currentLanguageIso\n    );\n\n    let formlyConfig: FormlyFieldConfig = {\n      key: control.identifier || control.title,\n      type: type,\n      props: {\n        currentLanguageIso: this.currentLanguageIso,\n        currentLanguageId: currentLanguageId,\n        label:\n          control.translations?.find(\n            (t: { languageIso: string }) =>\n              t.languageIso === this.currentLanguageIso\n          )?.value || '',\n\n        title:\n          control.translations?.find(\n            (t: { languageIso: string }) =>\n              t.languageIso === this.currentLanguageIso\n          )?.value || '',\n        design: this.design,\n        required: control.isMandatory,\n        attributes: {\n          style: componentsToExcludeFromStyle.find(\n            (c) => c === componentStyleKey\n          )\n            ? ''\n            : componentStyleKey,\n        },\n        autosize: true,\n        options: [{}],\n        fieldGroup: [],\n        autoDimension: control.autoDimension,\n      },\n      expressions: {},\n      hooks: {},\n      validators: {},\n    };\n    formlyConfig.validation = {};\n\n    if (control.specificControlData?.isMandatory && formlyConfig.props) {\n      var requiredMessage = Utils.findErrorTranslationValueOrDefault(\n        control.errorsTranslations,\n        this.currentLanguageIso,\n        'isMandatoryValidation'\n      );\n\n      formlyConfig.props.required = control.specificControlData?.isMandatory;\n      formlyConfig.validation.messages = {\n        ...formlyConfig.validation?.messages,\n        required: requiredMessage,\n      };\n    }\n\n    if (\n      control.type === StepControlType.Dictionary &&\n      control.specificControlData?.isMandatory &&\n      control.errorsTranslations &&\n      formlyConfig.props\n    ) {\n      var requiredMessage = Utils.findErrorTranslationValueOrDefault(\n        control.errorsTranslations,\n        this.currentLanguageIso,\n        'isMandatory'\n      );\n\n      formlyConfig.props.required = control.specificControlData?.isMandatory;\n      formlyConfig.validation.messages = {\n        ...formlyConfig.validation?.messages,\n        required: requiredMessage,\n      };\n    }\n\n    let simpleValidationMessage = '';\n    if (control.specificControlData?.isSimpleValidation && formlyConfig.props) {\n      if (\n        control.specificControlData?.isSimpleValidation &&\n        formlyConfig.props\n      ) {\n        simpleValidationMessage = Utils.findErrorTranslationValueOrDefault(\n          control.errorsTranslations,\n          this.currentLanguageIso,\n          'simpleValidation'\n        );\n\n        if (control.specificControlData?.minValue?.toString()) {\n          formlyConfig.props.min = control.specificControlData.minValue;\n          formlyConfig.validation.messages = {\n            ...formlyConfig.validation?.messages,\n            min: simpleValidationMessage,\n          };\n        }\n\n        if (control.specificControlData?.maxValue?.toString()) {\n          formlyConfig.props.max = control.specificControlData.maxValue;\n          formlyConfig.validation.messages = {\n            ...formlyConfig.validation?.messages,\n            max: simpleValidationMessage,\n          };\n        }\n      }\n\n      // Apply pattern validation if allowedCharacters is defined\n      if (control.specificControlData?.allowedCharacters) {\n        simpleValidationMessage = simpleValidationMessage =\n          Utils.findErrorTranslationValueOrDefault(\n            control.errorsTranslations,\n            this.currentLanguageIso,\n            'simpleValidation'\n          );\n\n        formlyConfig.validators = {\n          ...formlyConfig.validators,\n          customPattern: {\n            expression: (c: AbstractControl) => {\n              if (!c.value) return true;\n              try {\n                const regex = new RegExp(pattern);\n                return regex.test(c.value);\n              } catch {\n                return false;\n              }\n            },\n            message:\n              simpleValidationMessage ||\n              'Value does not match the required pattern',\n          },\n        };\n\n        formlyConfig.validation.messages = {\n          ...formlyConfig.validation?.messages,\n          pattern: simpleValidationMessage,\n        };\n      }\n\n      // Apply maxLength validation if maxCharacters is defined\n      if (control.specificControlData?.maxCharacters) {\n        formlyConfig.props.maxLength =\n          control.specificControlData?.maxCharacters;\n        formlyConfig.validation.messages = {\n          ...formlyConfig.validation?.messages,\n          maxLength: simpleValidationMessage,\n        };\n      }\n      if (\n        control.specificControlData?.allowOnlyFuture ||\n        control.specificControlData?.allowOnlyPast\n      ) {\n        formlyConfig.type = 'datepicker';\n        const checkDateValidation = {\n          checkDate: {\n            expression: (c: AbstractControl, field: FormlyFieldConfig) => {\n              simpleValidationMessage =\n                Utils.findErrorTranslationValueOrDefault(\n                  control.errorsTranslations,\n                  this.currentLanguageIso,\n                  'simpleValidation'\n                );\n\n              const currentDate = new Date();\n              currentDate.setHours(0, 0, 0, 0);\n\n              if (control.specificControlData?.allowOnlyFuture) {\n                if (!c.value || c.value === '') return true;\n                return c.value > currentDate;\n              }\n              if (control.specificControlData?.allowOnlyPast) {\n                if (!c.value || c.value === '') return true;\n                return c.value < currentDate;\n              }\n              return true;\n            },\n            message: (error: any, field: FormlyFieldConfig) => {\n              return simpleValidationMessage;\n            },\n          },\n        };\n        formlyConfig.validators = {\n          ...formlyConfig.validators,\n          ...checkDateValidation,\n        };\n      }\n    }\n\n    //control.specificControlData.type === 4  is phone\n    if (control.specificControlData?.type === 4) {\n      var phoneErrorLabel = this.flux?.find(\n        (f) => f?.config?.componentCollected === control?.identifier\n      )?.config?.phoneErrorLabel;\n      var phoneErrorLabelValue = '';\n      if (phoneErrorLabel != null && Array.isArray(phoneErrorLabel)) {\n        phoneErrorLabelValue =\n          (phoneErrorLabel as LabelInfo[]).find(\n            (l) => l.languageIso === this.currentLanguageIso\n          )?.value ?? '';\n      }\n\n      formlyConfig.validators = {\n        phoneValid: {\n          expression: (cont: AbstractControl) => {\n            const value = cont.value;\n            const phonePattern = new RegExp(\n              '^(\\\\+4|)?(07[0-8]{1}[0-9]{1}|02[0-9]{2}|03[0-9]{2}){1}?(\\\\s|\\\\.|-)?([0-9]{3}(\\\\s|\\\\.|-|)){2}$'\n            );\n            if (value && !phonePattern.test(value)) {\n              cont.setErrors({ invalidPhoneNumber: true });\n              return false;\n            }\n            return true;\n          },\n          message: phoneErrorLabelValue,\n        },\n      };\n    }\n\n    if (control.specificControlData?.type === 2) {\n      const checkDate2Validation = {\n        checkDate2: {\n          expression: (c: AbstractControl, field: FormlyFieldConfig) => {\n            var dateValue = c.value;\n            if (!dateValue && control.specificControlData?.isMandatory) {\n              simpleValidationMessage =\n                Utils.findErrorTranslationValueOrDefault(\n                  control.errorsTranslations,\n                  this.currentLanguageIso,\n                  'isMandatoryValidation'\n                );\n              return false;\n            }\n            if (\n              isNaN(Date.parse(dateValue)) &&\n              control.specificControlData?.isMandatory\n            )\n              return false;\n\n            return true;\n          },\n          message: (error: any, field: FormlyFieldConfig) => {\n            if (simpleValidationMessage === '')\n              return 'Please enter a valid date';\n\n            return simpleValidationMessage;\n          },\n        },\n      };\n      formlyConfig.validators = {\n        ...formlyConfig.validators,\n        ...checkDate2Validation,\n      };\n    }\n\n    return formlyConfig;\n  }\n\n  async buildPresentationFormFieldAsync(\n    step: StepData | undefined,\n    control: PresentationControl\n  ): Promise<FormlyFieldConfig> {\n    let formlyConfig: FormlyFieldConfig = { props: {} };\n\n    formlyConfig.type = 'formly-paragraph';\n    formlyConfig.className = 'component-text-field';\n    formlyConfig.props!['design'] = this.appModel.generatedCss;\n\n    var translatedTitle =\n      control.translations.find((d) => d.languageIso == this.currentLanguageIso)\n        ?.value ??\n      control.title ??\n      '';\n\n    if (control.type == PresentationControlType.Paragraph) {\n      const paragraphControl = control as PresentationParagraphControl;\n\n      var translatedDescription =\n        paragraphControl.specificControlData.descriptionTranslations.find(\n          (d: any) => d.languageIso == this.currentLanguageIso\n        )?.value ?? '';\n      var translatedParagraphTitle =\n        paragraphControl.specificControlData.text.find(\n          (d: any) => d.languageIso == this.currentLanguageIso\n        )?.value ?? '';\n\n      formlyConfig.defaultValue = translatedDescription;\n      formlyConfig.props!['translatedDescription'] = translatedDescription;\n      formlyConfig.props!['translatedParagraphTitle'] =\n        translatedParagraphTitle;\n      formlyConfig.type = 'formly-paragraph';\n      formlyConfig.className = 'component-text-field';\n    } else if (control.type == PresentationControlType.Download) {\n      formlyConfig = this.CreateDownloadDocsFieldConfig(control);\n    } else if (control.type == PresentationControlType.View) {\n      formlyConfig = this.CreateViewDocsFieldConfig(control);\n    } else if (control.type == PresentationControlType.Status) {\n      let statusName =\n        this.appModel.statuses.find(\n          (s) => s.id === this.fillData?.metadata.statusId\n        )?.name || 'no status name';\n\n      formlyConfig.defaultValue = statusName;\n      formlyConfig.type = 'formly-paragraph';\n      formlyConfig.className = 'component-text-field';\n    } else {\n      if (\n        control.type == PresentationControlType.FluxComponent &&\n        this.controlIdsWithValues &&\n        control.collectionControlIdentifier\n      ) {\n        const fillValue =\n          this.controlIdsWithValues[control.collectionControlIdentifier];\n        if (fillValue) {\n          switch (typeof fillValue) {\n            case 'boolean':\n              formlyConfig.defaultValue = fillValue ? '&check;' : '&cross;';\n              break;\n\n            default:\n              if (fillValue?.name) {\n                formlyConfig.defaultValue = fillValue.name;\n              } else {\n                formlyConfig.defaultValue = fillValue;\n              }\n              break;\n          }\n        }\n      }\n    }\n\n    formlyConfig.id = control.identifier;\n    formlyConfig.props!['isDisplayMode'] = true;\n    formlyConfig.props!['collectionControlIdentifier'] =\n      control.collectionControlIdentifier;\n    formlyConfig.props!['label'] = translatedTitle;\n    formlyConfig.props!['langIso'] = this.currentLanguageIso;\n\n    this.formlyPresentationFields.push(formlyConfig);\n\n    return formlyConfig;\n  }\n\n  async buildApiMethodFormFieldAsync(\n    step: StepData | undefined,\n    control: PresentationControl\n  ): Promise<FormlyFieldConfig> {\n    let formlyConfig: FormlyFieldConfig = { props: {} };\n\n    formlyConfig.type = 'formly-paragraph';\n    formlyConfig.className = 'component-text-field';\n    formlyConfig.props!['design'] = this.appModel.generatedCss;\n\n    var translatedTitle =\n      control.translations.find((d) => d.languageIso == this.currentLanguageIso)\n        ?.value ??\n      control.title ??\n      '';\n\n    formlyConfig.id = control.identifier;\n    formlyConfig.props!['isDisplayMode'] = true;\n    formlyConfig.props!['apiMethodId'] = control.apiMethodId;\n    formlyConfig.props!['apiMethodFieldId'] = control.apiMethodFieldId;\n    formlyConfig.props!['label'] = translatedTitle;\n\n    if (control.apiMethodFieldId) {\n      const val = this.findInApiCallsResponses(control.apiMethodFieldId);\n      formlyConfig.defaultValue = val;\n    }\n\n    this.formlyPresentationFields.push(formlyConfig);\n\n    return formlyConfig;\n  }\n\n  private attachToDependentDictionaryIfNecessary(\n    dependentDictionary: DependentDictionaryData,\n    formlyConfig: FormlyFieldConfig\n  ) {\n    // Handle dictionary dependencies\n    if (\n      dependentDictionary &&\n      dependentDictionary.dictionaryControlIdentifier\n    ) {\n      const parentKey = dependentDictionary.dictionaryControlIdentifier;\n      const dependentValueIds = dependentDictionary.dependentValueIds || [];\n\n      formlyConfig.expressions = {\n        hide: (field: FormlyFieldConfig) => {\n          const shouldShow = this.shouldShowDependentField(\n            parentKey,\n            dependentValueIds,\n            this.model\n          );\n          return !shouldShow;\n        },\n      };\n    }\n  }\n\n  private attachToValueChanges(controlId: string, options: FormlyFieldConfig) {\n    options.props!['onSelectedValueChanged'] = async (val: any) => {\n      this.model[controlId] = val;\n      var referenceDictionaries = Array.from(\n        this.dictionaryMap.values()\n      ).filter((d) => d.referenceId == val.dictionaryId);\n      if (referenceDictionaries?.length > 0) {\n        this.removeReferenceFields(options);\n\n        var referenceDictionariesWithFilteredValues =\n          this.createReferenceDictionariesFromSelectedValue(\n            referenceDictionaries,\n            val\n          );\n        const parentSpecificData = options.props?.[\n          'specificData'\n        ] as DictionaryControlData;\n        await this.addReferenceDictionaryFieldsIfNecessary(\n          referenceDictionariesWithFilteredValues,\n          options,\n          options.type,\n          parentSpecificData?.relatedDictionariesTranslations || []\n        );\n      } else {\n        this.removeReferenceFields(options);\n      }\n      this.updateFormlyConfig();\n    };\n  }\n\n  createReferenceDictionariesFromSelectedValue(\n    allDictionaries: DictionaryDto[],\n    selectedValue: any\n  ): DictionaryDto[] {\n    const newDictionaries: DictionaryDto[] = [];\n\n    allDictionaries.forEach((dictionary) => {\n      const filteredValues =\n        dictionary.values?.filter((value) =>\n          value.referenceValues.some(\n            (refValue) => refValue.id === selectedValue.id\n          )\n        ) || [];\n\n      if (filteredValues.length > 0) {\n        const newDictionary: DictionaryDto = {\n          ...dictionary,\n          values: filteredValues,\n        };\n\n        newDictionaries.push(newDictionary);\n      }\n    });\n\n    return newDictionaries;\n  }\n\n  shouldShowDependentField(\n    parentKey: string,\n    dependentValueIds: number[],\n    model: any = {}\n  ): boolean {\n    // Retrieve the value of the parent dictionary control\n    const parentValue = this.getNestedValue(\n      model,\n      parentKey\n    ) as DictionaryValue;\n\n    const idValue = parentValue?.id\n      ? parentValue.id\n      : (parentValue as unknown as number);\n    // Check if the parent value is in the dependentValueIds\n    if (parentValue && dependentValueIds.includes(idValue)) {\n      return true;\n    }\n    return false;\n  }\n\n  getNestedValue(obj: any, path: string): any {\n    const keys = path.split('.');\n    let value = obj;\n    for (const key of keys) {\n      value = value[key];\n      if (value === undefined) {\n        return undefined;\n      }\n    }\n    return value;\n  }\n\n  submit(): void {\n    console.log('Form Data:', this.form.value);\n    if (this.form.invalid) {\n      console.log('Form data has validation errors.');\n      this.scrollToErrorService.scrollToFirstError(this.form);\n    }\n  }\n\n  /**\n   * Public method to trigger scroll to first error - can be called from other components\n   */\n  public scrollToFirstValidationError(): void {\n    this.scrollToErrorService.scrollToFirstError(this.form);\n  }\n\n  /**\n   * Public method to scroll to a specific field by name\n   */\n  public scrollToField(fieldName: string): void {\n    this.scrollToErrorService.scrollToField(fieldName);\n  }\n\n  /**\n   * Debug method to help troubleshoot scroll issues\n   */\n  public debugFormElements(): void {\n    this.scrollToErrorService.debugLogFormElements();\n  }\n\n  async constructDictionary(\n    control: ControlData,\n    options: FormlyFieldConfig\n  ): Promise<void> {\n    const specificData = control.specificControlData;\n    options.type =\n      specificData.showAsRadioButtonsList === true\n        ? `formly-radio`\n        : `formly-dictionary-dropdown-tree`;\n\n    options.props!['specificData'] = specificData;\n\n    const dictionaryUuid = specificData.dictionaryUUID;\n\n    if (dictionaryUuid) {\n      const dictionary = this.dictionaryMap.get(dictionaryUuid);\n      if (dictionary) {\n        if (dictionary.referenceId) {\n          options.props!['dictionaryId'] = dictionaryUuid;\n          this.constructDictionaryWithReferences(\n            dictionary,\n            options,\n            specificData\n          );\n          this.attachToValueChanges(control.identifier, options);\n        } else {\n          options.type =\n            specificData.showAsRadioButtonsList === true\n              ? 'formly-radio'\n              : 'formly-dictionary-dropdown-tree';\n          options.props!['dictionaryId'] = dictionaryUuid;\n          this.constructDictionaryWithReferences(\n            dictionary,\n            options,\n            specificData\n          );\n          this.attachToValueChanges(control.identifier, options);\n        }\n      } else {\n        console.warn(`Dictionary not found for UUID ${dictionaryUuid}`);\n      }\n    } else {\n      console.warn(\n        `UUID not found for dictionary ID ${specificData.dictionaryId}`\n      );\n    }\n  }\n\n  private findDictionaryValueObject(\n    dictionary: DictionaryDto | undefined,\n    value: any\n  ): DictionaryValueDto | undefined {\n    if (\n      !dictionary ||\n      !dictionary.values ||\n      value === null ||\n      value === undefined\n    ) {\n      return undefined;\n    }\n    if (typeof value === 'object' && value?.id != null) {\n      return dictionary.values.find((v) => v.id === value.id);\n    } else if (typeof value === 'number' || typeof value === 'string') {\n      const valueId = Number(value);\n      if (!isNaN(valueId)) {\n        return dictionary.values.find((v) => v.id === valueId);\n      }\n    }\n    return undefined;\n  }\n\n  private async initializeReferenceFields(\n    fields: FormlyFieldConfig[],\n    rootConfig: FormlyFieldConfig[] = this.formlyConfig\n  ): Promise<void> {\n    if (!fields) return;\n    const fieldsToProcess = [...fields];\n\n    for (const field of fieldsToProcess) {\n      const fieldKey = field.key as string;\n      if (\n        fieldKey &&\n        field.props?.['dictionaryId'] &&\n        field.props?.['specificData']\n      ) {\n        const control = this.form.get(fieldKey);\n        const specificData = field.props[\n          'specificData'\n        ] as DictionaryControlData;\n        const dictionaryUuid = field.props['dictionaryId'] as string;\n        const mainDictionary = this.dictionaryMap.get(dictionaryUuid);\n\n        let valueToUse: any = null;\n\n        if (control && control.value !== null && control.value !== undefined) {\n          valueToUse = control.value;\n        } else if (\n          field.defaultValue !== null &&\n          field.defaultValue !== undefined\n        ) {\n          valueToUse = field.defaultValue;\n        } else if (\n          this.model &&\n          this.model[fieldKey] !== null &&\n          this.model[fieldKey] !== undefined\n        ) {\n          valueToUse = this.model[fieldKey];\n        }\n\n        let selectedValueObject: DictionaryValueDto | undefined | null = null;\n        if (valueToUse !== null && mainDictionary?.id != null) {\n          selectedValueObject = this.findDictionaryValueObject(\n            mainDictionary,\n            valueToUse\n          );\n        }\n\n        const fieldConfigInTree = this.findFieldByKey(rootConfig, fieldKey);\n        if (!fieldConfigInTree) {\n          continue;\n        }\n\n        this.removeReferenceFields(fieldConfigInTree);\n\n        if (\n          selectedValueObject &&\n          selectedValueObject.id != null &&\n          mainDictionary?.id != null\n        ) {\n          const potentialReferenceDictionaries = Array.from(\n            this.dictionaryMap.values()\n          ).filter((dict) => dict.referenceId === mainDictionary.id);\n\n          if (potentialReferenceDictionaries.length > 0) {\n            const referenceDictionariesToShow =\n              this.createReferenceDictionariesFromSelectedValue(\n                potentialReferenceDictionaries,\n                selectedValueObject\n              );\n\n            if (referenceDictionariesToShow.length > 0) {\n              await this.addReferenceDictionaryFieldsIfNecessary(\n                referenceDictionariesToShow,\n                fieldConfigInTree,\n                fieldConfigInTree.type,\n                specificData?.relatedDictionariesTranslations || []\n              );\n            }\n          }\n        }\n      }\n\n      if (field.fieldGroup && field.fieldGroup.length > 0) {\n        await this.initializeReferenceFields(field.fieldGroup, rootConfig);\n      }\n    }\n    if (\n      fields === this.formlyConfig ||\n      fields === this.formlyConfig[0]?.fieldGroup\n    ) {\n      this.updateFormlyConfig();\n      this.formlyConfigUpdated.emit();\n      this.cdRef.detectChanges();\n    }\n  }\n\n  constructDictionaryWithReferences(\n    dictionary: DictionaryDto,\n    options: FormlyFieldConfig,\n    dictionaryControlData: DictionaryControlData\n  ) {\n    if (options.props) {\n      var currentLanguageId = Utils.findLanguageIdByIso(\n        this.availableLanguages,\n        this.currentLanguageIso\n      );\n\n      // Pass preloaded dictionary data to formly component\n      options.props['dictionaryData'] = dictionary;\n      options.props['languages'] = this.availableLanguages;\n      options.props['preloadedDictionaries'] = this.dictionaryMap;\n      options.props['usePreloadedData'] = true;\n\n      options.props.options = dictionary.values?.map((value) => ({\n        value: value,\n        label:\n          Utils.findValueTranslation(\n            value.valueTranslations,\n            currentLanguageId\n          ) || value.name,\n        currentLanguageIso: this.currentLanguageIso,\n        relatedDictionariesTranslations:\n          dictionaryControlData.relatedDictionariesTranslations,\n      }));\n\n      options.props['selectedRelatedDictionaries'] =\n        dictionaryControlData.selectedRelatedDictionaries || [];\n\n      let initialValueObject: DictionaryValue | null = null;\n      const controlKey = options.key as string;\n      const dictionaryDefaultValueId =\n        dictionaryControlData.dictionaryDefaultValueId;\n      if (\n        !(this.model && this.model[controlKey] != null) &&\n        dictionaryDefaultValueId != null\n      ) {\n        initialValueObject = this.findAndMapDefaultValue(\n          dictionary,\n          dictionaryDefaultValueId\n        );\n      }\n\n      options.defaultValue = initialValueObject;\n\n      // Pass default value ID to formly component\n      options.props['dictionaryDefaultValueId'] = dictionaryDefaultValueId;\n\n      const controlId = options.key;\n      if (this.fillData && this.fillData.flux) {\n        for (const step of this.fillData.flux) {\n          for (const section of step.sections) {\n            const control = section.controls.find(\n              (ctrl: {\n                controlId: string | number | (string | number)[] | undefined;\n              }) => ctrl.controlId === controlId\n            );\n            if (control && control.fillValue && control.fillValue.name) {\n              options.props['value'] = control.fillValue.name;\n              break;\n            }\n          }\n        }\n      }\n    }\n    this.updateFormlyConfig();\n  }\n\n  async addReferenceDictionaryFieldsIfNecessary(\n    referrencedDictionaries: any[],\n    parentDictionaryField: FormlyFieldConfig,\n    type: any,\n    relatedDictionariesTranslations: DictionaryLabelInfo[]\n  ): Promise<void> {\n    if (referrencedDictionaries.length > 0) {\n      const selectedRelatedDictionaries =\n        parentDictionaryField.props?.['selectedRelatedDictionaries'] || [];\n\n      const selectedDictionaries = referrencedDictionaries.filter((dict) =>\n        selectedRelatedDictionaries.includes(dict.uuid)\n      );\n\n      selectedDictionaries.forEach((referenceDictionary) => {\n        const referenceDictionaryUuid = referenceDictionary.uuid;\n\n        const componentOnlyForConfig = this.flux\n          .flatMap((s) => s.sections)\n          .flatMap((sec) => sec.controls)\n          .find(\n            (ctrl) =>\n              ctrl?.specificControlData?.dictionaryUUID ===\n              referenceDictionaryUuid && ctrl?.isOnlyForConfig === true\n          );\n\n        const newFieldKey =\n          componentOnlyForConfig?.identifier ??\n          `extra_${referenceDictionaryUuid}`;\n\n        let referenceDictionaryLabel = referenceDictionary.name;\n\n        const specificTranslationValue = relatedDictionariesTranslations\n          .find((d) => d.dictionaryUUID == referenceDictionaryUuid)\n          ?.translations?.find(\n            (t) => t.languageIso == this.currentLanguageIso\n          )?.value;\n\n        if (\n          specificTranslationValue &&\n          specificTranslationValue.trim() !== ''\n        ) {\n          referenceDictionaryLabel = specificTranslationValue;\n        } else {\n          referenceDictionaryLabel = '';\n        }\n        const currentLanguageId = Utils.findLanguageIdByIso(\n          this.availableLanguages,\n          this.currentLanguageIso\n        );\n\n        const newField: FormlyFieldConfig = {\n          key: newFieldKey,\n          type: type,\n          props: {\n            label: referenceDictionaryLabel,\n            design: this.design,\n            dictionaryId: referenceDictionaryUuid,\n            dictionaryData: referenceDictionary,\n            languages: this.availableLanguages,\n            preloadedDictionaries: this.dictionaryMap,\n            usePreloadedData: true,\n            currentLanguageIso: this.currentLanguageIso,\n            currentLanguageId: currentLanguageId,\n            required: true,\n            attributes: {\n              style: this.styleObjectToStringExceptBackground(\n                this.design[`.font-list`] || {}\n              ),\n            },\n            options: referenceDictionary.values?.map((value: any) => ({\n              value: value,\n              label:\n                Utils.findValueTranslation(\n                  value.valueTranslations,\n                  currentLanguageId\n                ) || value.name,\n              currentLanguageIso: this.currentLanguageIso,\n            })),\n          },\n        };\n\n        if (referenceDictionary.defaultValueId) {\n          const defaultVal = this.findAndMapDefaultValue(\n            referenceDictionary,\n            referenceDictionary.defaultValueId\n          );\n          if (defaultVal) {\n            newField.defaultValue = defaultVal;\n          }\n        }\n\n        const parentFieldGroup = parentDictionaryField.parent\n          ? parentDictionaryField.parent.fieldGroup\n          : null;\n        if (parentFieldGroup) {\n          const parentIndex = parentFieldGroup.findIndex(\n            (field) => field.key === parentDictionaryField.key\n          );\n          if (parentIndex !== -1) {\n            const endIndex = this.findLastChildIndex(\n              parentFieldGroup,\n              parentIndex\n            );\n\n            const percentageToAdd = this.getExistingPercentage(\n              parentFieldGroup,\n              parentIndex\n            );\n            newField.className = percentageToAdd === 0\n              ? parentDictionaryField.className\n              : this.getPercentageClassName(percentageToAdd);\n\n            parentFieldGroup.splice(endIndex + 1, 0, newField);\n\n            const classNameToAdd =\n              type === 'radio' ? ` component-radio` : ` component-data`;\n            newField.className += classNameToAdd;\n            this.attachToValueChanges(newFieldKey, newField);\n            this.updateFormlyConfig();\n          }\n        }\n      });\n    }\n  }\n\n  getExistingPercentage(fields: FormlyFieldConfig[], index: number): number {\n    let percentage = 0;\n    const field = fields[index];\n    const className = field.className;\n    if (field.type?.toString() !== StepControlType.NewRow.toString()) {\n      if (className && className.startsWith('percentage-width-')) {\n        percentage =\n          (parseInt(className.replace('percentage-width-', ''), 10) * 100) / 12;\n      } else if (className && className.startsWith('pixel-width-')) {\n        const pixels = parseInt(className.replace('pixel-width-', ''), 10);\n        percentage = (pixels / 1000) * 100;\n      }\n    }\n    return percentage;\n  }\n\n  calculateRemainingPercentageForRange(\n    fields: FormlyFieldConfig[],\n    startIndex: number,\n    endIndex: number\n  ): number {\n    let remainingPercentage = 100;\n\n    for (let i = startIndex; i <= endIndex; i++) {\n      const percentage = this.getExistingPercentage(fields, i);\n      remainingPercentage -= percentage;\n    }\n    return Math.max(remainingPercentage, 0);\n  }\n\n  removeReferenceFields(currentFormlyFieldConfig: FormlyFieldConfig) {\n    const referredInDictionariesUUIds =\n      currentFormlyFieldConfig.props?.['dictionaryData']\n        ?.referredInDictionariesUUIds;\n\n    if (Array.isArray(referredInDictionariesUUIds)) {\n      const parentFieldGroup = currentFormlyFieldConfig.parent\n        ? currentFormlyFieldConfig.parent.fieldGroup\n        : null;\n      if (parentFieldGroup) {\n        const parentIndex = parentFieldGroup.findIndex(\n          (field) => field.key === currentFormlyFieldConfig.key\n        );\n\n        if (parentIndex !== -1) {\n          for (const item of referredInDictionariesUUIds) {\n            const idToFind = 'extra_' + item;\n\n            for (let i = parentFieldGroup.length - 1; i > parentIndex; i--) {\n              const currentFieldKey = parentFieldGroup[i].key?.toString();\n              if (currentFieldKey && currentFieldKey === idToFind) {\n                this.clearFormControlValue(idToFind);\n                parentFieldGroup.splice(i, 1);\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  async addChildDictionaryField(\n    childDictionaryUuid: string,\n    parentDictionaryField: FormlyFieldConfig,\n    type: any,\n    relatedDictionariesTranslations: DictionaryLabelInfo[]\n  ): Promise<void> {\n    if (childDictionaryUuid) {\n      const childDictionary = this.dictionaryMap.get(childDictionaryUuid);\n      if (childDictionary) {\n        let childDictionaryLabel = childDictionary.name;\n        const translation =\n          relatedDictionariesTranslations\n            .find((d) => d.dictionaryUUID == childDictionaryUuid)\n            ?.translations.find((t) => t.languageIso == this.currentLanguageIso)\n            ?.value || '';\n        if (translation) {\n          childDictionaryLabel = translation;\n        }\n        const newField: FormlyFieldConfig = {\n          key: `${parentDictionaryField.key}_child_${childDictionaryUuid}`,\n          type: type,\n          props: {\n            label: childDictionaryLabel,\n            dictionaryData: childDictionary,\n            languages: this.availableLanguages,\n            preloadedDictionaries: this.dictionaryMap,\n            options: childDictionary.values?.map((value) => ({\n              value: value.id,\n              label: value.name,\n            })),\n            required: true,\n            attributes: {\n              style: this.styleObjectToStringExceptBackground(\n                this.design[`.font-list`] || {}\n              ),\n            },\n          },\n          hooks: {\n            onInit: (field) => {\n              const unsubscribe$ = new Subject<void>();\n              this.fieldUnsubscribeSubjects.push(unsubscribe$);\n\n              field.formControl?.valueChanges\n                .pipe(takeUntil(unsubscribe$))\n                .subscribe(async (selectedValue) => {\n                  const selectedOption = childDictionary.values?.find(\n                    (val) => val.id === selectedValue\n                  );\n                  if (selectedOption && selectedOption.childDictionaryUUID) {\n                    await this.addChildDictionaryField(\n                      selectedOption.childDictionaryUUID,\n                      field,\n                      type,\n                      relatedDictionariesTranslations\n                    );\n                  } else {\n                    this.removeChildFields(field);\n                    this.updateFormlyConfig();\n                  }\n                });\n\n              field.hooks!.onDestroy = () => {\n                unsubscribe$.next();\n                unsubscribe$.complete();\n              };\n            },\n          },\n        };\n\n        const parentFieldGroup = parentDictionaryField.parent\n          ? parentDictionaryField.parent.fieldGroup\n          : null;\n        if (parentFieldGroup) {\n          const parentIndex = parentFieldGroup.findIndex(\n            (field) => field.key === parentDictionaryField.key\n          );\n          if (parentIndex !== -1) {\n            const endIndex = this.findLastChildIndex(\n              parentFieldGroup,\n              parentIndex\n            );\n\n            const percentageToAdd = this.getExistingPercentage(\n              parentFieldGroup,\n              parentIndex\n            );\n            newField.className = this.getPercentageClassName(percentageToAdd);\n            parentFieldGroup.splice(endIndex + 1, 0, newField);\n\n            const classNameToAdd =\n              type === 'radio' ? ` component-radio` : ` component-data`;\n            newField.className += classNameToAdd;\n            //this.attachToValueChanges(newFieldKey, newField);\n            this.updateFormlyConfig();\n          }\n        }\n      } else {\n        console.warn(\n          `Child dictionary not found for UUID ${childDictionaryUuid}`\n        );\n      }\n    }\n  }\n\n  onCompletion(): void {\n    console.log('Origin form completed successfully');\n    this.completionEvent.emit();\n  }\n\n  findLastChildIndex(fields: FormlyFieldConfig[], parentIndex: number): number {\n    const parentKeyPrefix = `${fields[parentIndex].key}_`;\n    let lastIndex = parentIndex;\n\n    for (let i = parentIndex + 1; i < fields.length; i++) {\n      if (fields[i].key?.toString().startsWith(parentKeyPrefix)) {\n        lastIndex = i;\n      } else {\n        break;\n      }\n    }\n\n    return lastIndex;\n  }\n\n  findFieldByKey(\n    fields: FormlyFieldConfig[],\n    key: string\n  ): FormlyFieldConfig | null {\n    if (!fields) return null;\n    for (const field of fields) {\n      if (field.type === 'stepper' && field.fieldGroup) {\n        const foundInStepper = this.findFieldByKey(field.fieldGroup, key);\n        if (foundInStepper) return foundInStepper;\n      }\n\n      if (field.key === key) {\n        return field;\n      }\n      if (field.fieldGroup) {\n        const found = this.findFieldByKey(field.fieldGroup, key);\n        if (found) return found;\n      }\n    }\n    return null;\n  }\n\n  removeChildFields(parentField: FormlyFieldConfig) {\n    const parentFieldGroup = parentField.parent\n      ? parentField.parent.fieldGroup\n      : null;\n\n    if (parentFieldGroup) {\n      const parentIndex = parentFieldGroup.findIndex(\n        (field) => field.key === parentField.key\n      );\n\n      if (parentIndex !== -1) {\n        const parentKeyPrefix = `${parentField.key}_child_`;\n\n        // Remove only the relevant child fields\n        for (let i = parentFieldGroup.length - 1; i > parentIndex; i--) {\n          const currentFieldKey = parentFieldGroup[i].key?.toString();\n          if (currentFieldKey && currentFieldKey.startsWith(parentKeyPrefix)) {\n            this.clearFormControlValue(currentFieldKey);\n            parentFieldGroup.splice(i, 1);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * NEW: Load ALL dictionaries needed for this app using the new app-based endpoint\n   */\n  private async loadAllRequiredDictionaries(): Promise<void> {\n    if (!this.appModel?.applicationUuid) {\n      console.warn('No app UUID available for dictionary loading');\n      return;\n    }\n\n    try {\n      const response = await firstValueFrom(\n        this.service.loadAppDictionaries(\n          this.appModel.applicationUuid,\n          EnvironmentType.Config\n        )\n      );\n\n      if (!response.success) {\n        console.error(\n          '❌ Backend failed to load dictionaries:',\n          response.errors\n        );\n        return;\n      }\n\n      // Simple assignment - ALL dictionaries and dependencies already loaded by backend\n      Object.entries(response.dictionaries).forEach(([uuid, dict]) => {\n        this.dictionaryMap.set(uuid, dict);\n      });\n    } catch (error) {\n      console.error('❌ Failed to load app dictionaries:', error);\n    }\n  }\n\n  clearFormControlValue(fieldKey: string) {\n    const keys = fieldKey.split('.');\n    let control = this.form;\n    let model = this.model;\n\n    for (let i = 0; i < keys.length - 1; i++) {\n      control = control.get(keys[i]) as FormGroup;\n      model = model[keys[i]];\n    }\n\n    const finalKey = keys[keys.length - 1];\n    if (control && control.get(finalKey)) {\n      control.removeControl(finalKey);\n    }\n\n    if (model && model[finalKey] !== undefined) {\n      delete model[finalKey];\n    }\n  }\n\n  findField(\n    fields: FormlyFieldConfig[],\n    key: string\n  ): FormlyFieldConfig | null {\n    for (const field of fields) {\n      if (field.key === key) {\n        return field;\n      }\n      if (field.fieldGroup) {\n        const nestedField = this.findField(field.fieldGroup, key);\n        if (nestedField) {\n          return nestedField;\n        }\n      }\n    }\n    return null;\n  }\n\n  private populateModelWithFillData(fillData: any): void {\n    if (fillData) {\n      let auxModel = ModelPopulationHelper.populateModelWithFillData(\n        fillData,\n        this.flux,\n        this.dictionaryMap,\n        this.availableLanguages\n      );\n      this.model = { ...auxModel };\n      this.cdRef.detectChanges();\n    }\n  }\n\n  private findAndMapDefaultValue(\n    dictionary: DictionaryDto | undefined,\n    defaultValueId: number\n  ): DictionaryValue | null {\n    return ModelPopulationHelper.findAndMapDefaultValue(\n      dictionary,\n      defaultValueId,\n      this.availableLanguages\n    );\n  }\n\n  updateFormlyConfig() {\n    this.formlyConfig = [...this.formlyConfig];\n  }\n\n  private unsubscribeFromAllFields() {\n    for (const subject of this.fieldUnsubscribeSubjects) {\n      subject.next();\n      subject.complete();\n    }\n    this.fieldUnsubscribeSubjects = [];\n  }\n\n  ngOnDestroy() {\n    this.unsubscribeFromAllFields();\n    if (this.collectorHandlerSubscriptions) {\n      this.collectorHandlerSubscriptions.unsubscribe();\n    }\n    if (this.actionStepSubscriptions) {\n      this.actionStepSubscriptions.unsubscribe();\n    }\n    if (this.actionStepHandler) {\n      this.actionStepHandler.destroy();\n    }\n  }\n\n  constructButtons(buttonsConfig: any[]): any[] {\n    if (!buttonsConfig || buttonsConfig.length === 0) {\n      return [];\n    }\n    return buttonsConfig.map((button) => ({\n      type: button.value.toLowerCase(),\n      label: button.translations?.[this.currentLanguageIso] || button.value,\n      styleKey: `.button-${button.value.toLowerCase()}`,\n    }));\n  }\n\n  private styleObjectToStringExceptBackground(styleObj: any): string {\n    return Object.entries(styleObj)\n      .filter(([key, value]) => key !== 'background-color')\n      .map(([key, value]) => `${key}: ${value}`)\n      .join('; ');\n  }\n\n  validateMethodApi(data: ApiValidateRequest): Observable<boolean> {\n    if (data.apiId === undefined || data.appId === undefined) {\n      return of(false);\n    }\n\n    return this.applicationDataService.validateApi(data).pipe(\n      map((response) => {\n        console.log('API validation response:', response);\n        return !!response;\n      }),\n      catchError((error) => {\n        console.error('Error validating ' + data.data, error);\n        return of(false);\n      })\n    );\n  }\n\n  /**\n   * Public method to clear the saving after actions state\n   * Called by stepper component after saveAppDataStep completes\n   */\n  public clearSavingAfterActionsState(): void {\n    if (this.isSavingAfterActions) {\n      this.isSavingAfterActions = false;\n      this.isLoading = false;\n      this.cdRef.detectChanges();\n    }\n  }\n  loadingMessage: string | null = null;\n}\n","<div *ngIf=\"isLoading\" class=\"loading-overlay\">\n  <mat-spinner></mat-spinner>\n</div>\n<div [hidden]=\"isLoading\">\n  <div *ngIf=\"showLanguageSelector\" appearance=\"outline\" class=\"right-aligned\">\n    <button [matMenuTriggerFor]=\"flags\" mat-icon-button class=\"m-r-5\">\n      <img\n        [src]=\"returnFLag(currentLanguageIso)\"\n        class=\"rounded-circle object-cover icon-20\"\n      />\n    </button>\n    <mat-menu #flags=\"matMenu\" class=\"cardWithShadow\">\n      <button\n        mat-menu-item\n        *ngFor=\"let lang of applicationLanguages()\"\n        (click)=\"changeLanguage(lang.iso)\"\n      >\n        <div class=\"d-flex align-items-center\">\n          <img\n            [src]=\"returnFLag(lang.iso)\"\n            class=\"rounded-circle object-cover icon-20\"\n          />\n          <span class=\"mat-subtitle-1 f-s-14\">{{ lang.name }}</span>\n        </div>\n      </button>\n    </mat-menu>\n  </div>\n\n  <br />\n  <div class=\"form-container\">\n    <form [formGroup]=\"form\" (ngSubmit)=\"submit()\">\n      <formly-form\n        [model]=\"model\"\n        [fields]=\"formlyConfig\"\n        [options]=\"options\"\n        [form]=\"form\"\n      ></formly-form>\n    </form>\n  </div>\n</div>\n"]}