@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_modules/ngx-models/_models/control-models/data-handler.control-model.js

@@ -0,0 +1,407 @@
+import { DyFM_Log, second } from '../../../..';
+/**
+ * DynamoDataHandler is used to create application wide data handling
+ * used to create subscribeAble data handler
+ *
+ * this implements data reload function that uses predefined apiService,
+ * using previous or given id,
+ * prevents multiple load calls and triggers data change subscriptions when done
+ *
+ * load post processes can be implemented to ensure special conditions
+ *
+ * @example
+ * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
+ *   apiService: this.accountApiService,
+ *   getDataFunctionName: 'getPersonalInformation',
+ * });
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export class DyFM_DataHandler_ControlModel {
+    name;
+    get data() {
+        return this.data_$();
+    }
+    /**
+     * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
+     */
+    lastLoadedBy; // for lists
+    /** this will handle the data loading from the api */
+    get;
+    /** this will handle the data setting to the data handler */
+    set;
+    /** this will handle the data patching to the data handler */
+    /* patch: (data: T) => Promise<T>; */
+    // TODO
+    /* directApiSetup: any; */
+    /**
+     * post processes will be called as pipes after data is loaded by get function,
+     * but before data is set to data handler by data_$.set (after get, before Signal triggers)
+     */
+    getPostProcesses = [];
+    /** @deprecated Use isIdOmitted; noId remains the serialized compatibility key. */
+    noId;
+    waitsOnLoad = [];
+    dependentDataHandlers = [];
+    loopSafetyCollection = [];
+    loopSafetyTimeout = second;
+    /** if set to 0, loop safety will be disabled */
+    loopSafety = 10;
+    /** @deprecated Use isDebugLogEnabled; debugLog remains the serialized compatibility key. */
+    debugLog;
+    /**
+     * DynamoDataHandler
+     * @param apiService any service can be used as apiService
+     * as long as the function, you pass in getDataFunctionName exists,
+     * uses (or not uses an ID as input) and returns the data as Promise<Type>
+     * @param getDataFunctionName the function name on the apiService,
+     * that will be used as get api call
+     *
+     * @param successfulReloadCallBack you can create direct callback for successful reloads
+     * by passing it here
+     *
+     * @param getPostPreprocessLoad post processes can be implemented to ensure special conditions on data
+     *
+     * @param defaultValue you can set default value that will be used before any load
+     * @param noId this flag needs to be true, when using api function without id
+     *
+     * @example
+     * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
+     *   apiService: this.accountApiService,
+     *   getDataFunctionName: 'getPersonalInformation',
+     * });
+     */
+    constructor(set, 
+    /** is in construct?
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections) {
+        try {
+            // TODO: + TRYTOGETTYPE(this.data);
+            if (!set.name) {
+                set.name = 'Unnamed DataHandler ' + (+new Date());
+                DyFM_Log.warn(`DYNAMO DH.constructor (${this.name}) WARN: ` +
+                    `\n  Name is not set!`, '\n\n', new Error());
+            }
+            this.name = set.name;
+            this.debugLog = set?.debugLog;
+            if (set.loopSafety === undefined) {
+                set.loopSafety = 10;
+            }
+            else {
+                this.loopSafety = set.loopSafety;
+            }
+            if (set.get) {
+                this.get = set.get;
+            }
+            if (set.set) {
+                this.set = set.set;
+            }
+            this.noId = !!set.noId;
+            if (!skipDependencyConnections) {
+                if (set.dependencyDataHandler) {
+                    this.addDependencyDataHandler(set.dependencyDataHandler, true);
+                }
+                if (set.dependentDataHandlers) {
+                    this.addDependentDataHandlers(set.dependentDataHandlers, true);
+                }
+            }
+            if (set.getPostProcess) {
+                this.getPostProcesses.push(set.getPostProcess);
+            }
+        }
+        catch (error) {
+            DyFM_Log.error(`Error creating DyFM_DataHandler_ControlModel (${set.name}):`, error);
+        }
+    }
+    addDependencyDataHandler(dependencyDataHandler, isInConstruct) {
+        try {
+            if (!dependencyDataHandler) {
+                throw new Error(`DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+                    `\n  Dependent DataHandler is null or undefined! (${this.name})`);
+            }
+            if (!(dependencyDataHandler instanceof DyFM_DataHandler_ControlModel)) {
+                throw new Error(`DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+                    `\n  Dependent DataHandler is not instance of DyFM_DataHandler_ControlModel! (${this.name})`);
+            }
+            dependencyDataHandler.addDependentDataHandlers([this], isInConstruct);
+        }
+        catch (error) {
+            console.error(`DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+                `\n  Failed to add dependency data handler! ("${this.name}": "${this.constructor.name}")`, '\n\n', error, '\n\n', new Error());
+        }
+    }
+    addDependentDataHandlers(dependentDataHandlers, isInConstruct) {
+        try {
+            dependentDataHandlers.forEach((dependent_DH) => {
+                if (!dependent_DH) {
+                    throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+                        `\n  Dependent DataHandler is null or undefined! (${this.name})`);
+                }
+                if (!(dependent_DH instanceof DyFM_DataHandler_ControlModel)) {
+                    throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+                        `\n  Dependent DataHandler is not instance of DyFM_DataHandler_ControlModel! (${this.name})`);
+                }
+                if (dependent_DH.name === this.name) {
+                    throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+                        `\n  Dependent DataHandler has the same name as the current DataHandler! (${this.name})`);
+                }
+                if (!dependent_DH.data_$) {
+                    throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+                        `\n  Dependent DataHandler has not been set up yet! ` +
+                        `(this: "${this.name}", dependent: "${dependent_DH.name}")` +
+                        `\n    Try the opposite direction of dependency!\n\n`);
+                }
+                if (!dependentDataHandlers.includes(dependent_DH)) {
+                    dependentDataHandlers.push(dependent_DH);
+                }
+                if (this.debugLog) {
+                    this.getPostProcesses.push(async (newData) => {
+                        console.log(`DYNAMO DH.addDependentDataHandlers (${this.name}) DEBUG:` +
+                            `\nDataHandler triggering dependent dataHandler (${dependent_DH.name}) to reload... ` +
+                            `\n(using id: ${newData && newData['_id'] ? newData['_id'] : ''})`);
+                        return newData;
+                    });
+                }
+                // Dependency _id változásának követése - csak akkor reload-oljuk a dependenseket, ha a dependency _id ténylegesen változott
+                // Inicializáljuk az aktuális dependency _id-vel, ha már van adat
+                /* let previousDependencyId: any = this.data && this.data['_id'] ? this.data['_id'] : undefined; */
+                this.getPostProcesses.push(async (newData) => {
+                    if (newData && newData['_id'] && newData['_id'] !== dependent_DH.lastLoadedBy) {
+                        dependent_DH.reloadData(newData['_id']);
+                    }
+                    else if (!newData) {
+                        dependent_DH.clear();
+                    }
+                    /* const currentDependencyId = newData && newData['_id'] ? newData['_id'] : undefined;
+                    
+                    // Csak akkor reload-olunk, ha a dependency _id ténylegesen változott
+                    if (currentDependencyId && currentDependencyId !== previousDependencyId) {
+                      previousDependencyId = currentDependencyId;
+                      if (currentDependencyId !== dependent_DH.lastLoadedBy) {
+                        dependent_DH.reloadData(currentDependencyId);
+                      }
+                    } else if (!newData && previousDependencyId !== undefined) {
+                      previousDependencyId = undefined;
+                      dependent_DH.clear();
+                    } */
+                    return newData;
+                });
+                if (!isInConstruct && this.data) {
+                    dependent_DH.reloadData(this.data['_id']);
+                }
+            });
+        }
+        catch (error) {
+            DyFM_Log.error(`Error adding dependent data handlers in DyFM_DataHandler_ControlModel (${this.name}):`, error);
+        }
+    }
+    /**
+     * reloads data on DynamoDataHandler using predefined apiservice,
+     * using previous or given id,
+     * prevents multiple load calls and triggers data change subscriptions when done
+     * @param loadBy previous or given id (or can be disabled trough setup by: { noId: true })
+     * @param opts BFR-MASTERPROMPTER-024: `silentMissingId` — a hiányzó-ID ág NE console.error-ozzon
+     *   (a throw MARAD). A `getData()` not-loaded-yet útja használja: friss boot-on a dependency-cascade
+     *   (header token-balance/user-data read) a session-restore ELŐTT ér ide → az ID-hiány ott
+     *   „még-nincs-betöltve", NEM caller-hiba — a korábbi feltétel-nélküli console.error minden
+     *   hard-nav-on 2 hamis error-t tett a konzolra (release-gate-zaj). Direct `reloadData()`-hívásnál
+     *   a hiba-log változatlan (valódi caller-hiba látható marad).
+     * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
+     */
+    async reloadData(loadBy, opts) {
+        try {
+            const loadInProgress = this.loadInProgress_$();
+            const useLoadBy = loadBy ??
+                (this.data && this.data['_id'] ? this.data['_id'] : this.lastLoadedBy);
+            if (!useLoadBy && !this.noId) {
+                if (!opts?.silentMissingId) {
+                    console.error(`DynamoERROR (DH.reloadData): Missing ID! (${this.name})`, this.data, '\n\n', new Error());
+                }
+                throw new Error(`DynamoERROR (DH.reloadData): Missing ID! (${this.name})`);
+            }
+            if (loadInProgress && loadInProgress.loadBy === useLoadBy) {
+                if (this.debugLog) {
+                    console.log(`DYNAMO DH.reloadData (${this.name}) DEBUG:` +
+                        `\n  DataHandler reloadData... (using id: ${useLoadBy})` +
+                        `\n  DataHandler is already loading data... (awaiting it)`);
+                }
+                // BFR-MASTERPROMPTER-074: a second call for the SAME key awaits the load in flight. Returning `this.data`
+                // here handed the caller the not-yet-loaded (undefined / stale) value - measured: MP "Create Flow" during the
+                // first `loadMyFlows()` got `undefined` and crashed on `myFlows.find`. Same contract as `getData()`.
+                return await loadInProgress.progress;
+            }
+            if (this.debugLog) {
+                console.log(`DYNAMO DH.reloadData (${this.name}) DEBUG:` +
+                    `\n  DataHandler reloadData... (using id: ${useLoadBy})`);
+            }
+            const loadProgress = this.doReloadDataBy(useLoadBy);
+            this.loadInProgress_$.set({
+                loadBy: useLoadBy,
+                progress: loadProgress
+            });
+            // clears the in-flight marker on BOTH outcomes; `.finally()` returned a derived promise that rejected unhandled on
+            // every failed load (an "Uncaught (in promise)" beside the real error) — the caller already receives the error
+            const clearInProgress = () => {
+                this.loadInProgress_$.set(false);
+            };
+            loadProgress.then(clearInProgress, clearInProgress);
+            return await loadProgress;
+        }
+        catch (error) {
+            this.loadInProgress_$.set(false);
+            this.loaded_$.set(false);
+            if (!error?.error?.handled) {
+                console.error(`DYNAMO DH.reloadData (${this.name}) ERROR: ` +
+                    `\n  reloadData was UNSUCCESSFUL`, '\n\n', error, '\n\n', new Error());
+                if (error?.error?.flag?.includes('DYNAMO')) {
+                    error.error.handled = true;
+                }
+            }
+            throw error;
+        }
+    }
+    async getData() {
+        if (!this.data) {
+            const loadProgress = this.loadInProgress_$();
+            if (loadProgress) {
+                return await loadProgress.progress;
+            }
+            else {
+                // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján a hiányzó ID „még-nincs-betöltve"
+                // (boot-race a session-restore-ral), NEM caller-hiba → silent (a throw marad, a hívó catch-eli).
+                return await this.reloadData(undefined, { silentMissingId: true });
+            }
+        }
+        else {
+            return this.data;
+        }
+    }
+    async doReloadDataBy(loadedBy) {
+        try {
+            this.lastLoadedBy = loadedBy;
+            return await this.processLoadResult(await this.get(loadedBy), loadedBy);
+        }
+        catch (error) {
+            this.resolveWaitsOnLoad();
+            throw error;
+        }
+    }
+    /**
+     * Az adat közvetlen frissítése (round-trip nélkül; pl. SPA-login → user_DH.updateData). Alapból CSAK
+     * a saját `data_$`-t frissíti.
+     *
+     * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a dependent DataHandler-eket
+     *   (pl. token-balance) is újratölti az új adat `_id`-jével — a `reloadData` post-process
+     *   dependent-lánca az `updateData` (round-trip-mentes) úton eddig NEM futott → a friss SPA-login után
+     *   a dependent-DH-adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe: a vak
+     *   dependent-reload HTTP-flood-ot okozhatna, az updateData szándéka épp a szerver-hívás elkerülése).
+     */
+    async updateData(data, dontSendUpdate, reloadDependents) {
+        if (this.set && !dontSendUpdate) {
+            this.data_$.set(await this.set(data));
+        }
+        else {
+            this.data_$.set(data);
+        }
+        if (reloadDependents) {
+            // ugyanaz a reload-vagy-clear logika, mint a reloadData dependent-lánc-postprocess-e
+            this.dependentDataHandlers?.forEach((dependent_DH) => {
+                if (data && data['_id'] && data['_id'] !== dependent_DH.lastLoadedBy) {
+                    dependent_DH.reloadData(data['_id']);
+                }
+                else if (!data) {
+                    dependent_DH.clear();
+                }
+            });
+        }
+    }
+    clear(dontClearDependents) {
+        this.data_$.set(undefined);
+        this.lastLoadedBy = undefined;
+        if (!dontClearDependents) {
+            this.dependentDataHandlers.forEach((ddh) => {
+                ddh.clear();
+            });
+        }
+    }
+    async processLoadResult(result, loadedBy) {
+        try {
+            if (this.debugLog) {
+                console.log(`DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
+                    `\n  DataHandler processLoadResult... (using id: ${loadedBy})` +
+                    `\n  Result:`, result);
+            }
+            for (const postProcess of this.getPostProcesses) {
+                if (this.debugLog) {
+                    console.log(`DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
+                        `\n  Post process:`, postProcess);
+                }
+                result = await postProcess(result, loadedBy);
+                if (!result) {
+                    DyFM_Log.warn(`DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
+                        `\nPost process returned null or undefined!`, '\n\n', new Error());
+                }
+            }
+            this.data_$.set(result);
+            this.loaded_$.set(true);
+            this.resolveWaitsOnLoad();
+            return result;
+        }
+        catch (error) {
+            DyFM_Log.error(`Error in DH.processLoadResult (${this.name}):`, error);
+            throw error;
+        }
+    }
+    resolveWaitsOnLoad() {
+        this.waitsOnLoad.forEach(({ promise, resolve }) => {
+            resolve();
+        });
+        this.waitsOnLoad = [];
+    }
+    /**
+     * waits for the first load to finish
+     * @returns a promise that resolves when the first load finishes after this "subscription"
+     */
+    waitForLoad() {
+        let resolve;
+        const promise = new Promise((r) => { resolve = r; });
+        this.waitsOnLoad.push({ promise, resolve });
+        return promise;
+    }
+    loopSafetyCheck() {
+        this.loopSafetyCollection = this.loopSafetyCollection.filter((item) => item.at.getTime() > new Date().getTime() - this.loopSafetyTimeout);
+        this.loopSafetyCollection.push({
+            at: new Date(),
+            stack: new Error().stack,
+        });
+        if (this.loopSafetyCollection.length > this.loopSafety) {
+            throw new Error(`DYNAMO DH.loopSafetyCheck (${this.name}) ERROR: ` +
+                `\n  Loop safety triggered! Count: ${this.loopSafetyCollection.length}` +
+                `\n  Timeout: ${this.loopSafetyTimeout} MaxCount: ${this.loopSafety} Stack: ${new Error().stack}`);
+        }
+    }
+}
+Object.defineProperty(DyFM_DataHandler_ControlModel.prototype, 'isIdOmitted', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.noId;
+    },
+    set: function (isValue) {
+        this.noId = isValue;
+    },
+});
+Object.defineProperty(DyFM_DataHandler_ControlModel.prototype, 'isDebugLogEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.debugLog;
+    },
+    set: function (isValue) {
+        this.debugLog = isValue;
+    },
+});
+Object.defineProperty(DyFM_DataHandler_ControlModel, 'name', { value: 'DyFM_SignalDataHandler' });
+/** @deprecated Use DyFM_DataHandler_ControlModel. Same constructor; no API removal. */
+export { DyFM_DataHandler_ControlModel as DyFM_SignalDataHandler };

package/build-esm/_modules/ngx-models/_models/control-models/errors/error-notification.control-model.js

@@ -0,0 +1,43 @@
+/**
+ * CCAP-mirror Wave-1a — Runtime notification record.
+ *
+ * A `DyNX_Errors_ControlService.errors_$: WritableSignal<DyFM_ErrorNotification_ControlModel[]>`
+ * lista eleme. CCAP `errors_$[]` minta. Server-side NEM persisted — futás-időben él.
+ *
+ * @see _specifications/ccap-mirror/02-architecture-spec.md (J szakasz)
+ */
+export class DyFM_ErrorNotification_ControlModel {
+    /** Egyedi id (UUID vagy timestamp + random). */
+    id;
+    /** Megjelenítendő rövid üzenet. */
+    message;
+    /** Error-source label (pl. `'http'`, `'socket'`, `'angular-unhandled'`). */
+    source;
+    /** Severity szint — a Tailwind szín-token-t ez vezérli. */
+    level;
+    /** Vizuális szín-token (UI-fix override). Ha hiányzik, `level`-ből származtatva. */
+    color;
+    /** Eredeti error referencia (modal-detail nézethez). */
+    originalError;
+    /** Timestamp ISO 8601. */
+    createdAt;
+    /** Ennyi occurrence már volt (server-side dedup után frissül; client-side csak 1). */
+    occurrenceCount;
+    /** Auto-dismiss ezen időpont után (ISO 8601). Ha hiányzik, manual-dismiss. */
+    autoDismissAt;
+    constructor(set = {}) {
+        if (!set.id) {
+            throw new Error('DyFM_ErrorNotification_ControlModel: `id` is required');
+        }
+        if (!set.message) {
+            throw new Error('DyFM_ErrorNotification_ControlModel: `message` is required');
+        }
+        if (!set.createdAt) {
+            set.createdAt = new Date().toISOString();
+        }
+        Object.assign(this, set);
+    }
+}
+Object.defineProperty(DyFM_ErrorNotification_ControlModel, 'name', { value: 'DyFM_ErrorNotification' });
+/** @deprecated Use DyFM_ErrorNotification_ControlModel. Same constructor; no API removal. */
+export { DyFM_ErrorNotification_ControlModel as DyFM_ErrorNotification };

package/build-esm/_modules/ngx-models/_models/control-models/errors/error-settings.control-model.js

@@ -0,0 +1,64 @@
+/**
+ * CCAP-mirror Wave-1a — Single error display Settings.
+ *
+ * A `DyNX_Error_Component` (single error renderer) POJO konfigurációja.
+ * Server-importálható; minden mező optional, primitív vagy enum.
+ *
+ * Function-handler-ek (onCopy, onSendToInput, ...) NEM ezen az osztályon —
+ * a Params constructor `runtimeOptions` argumentumában.
+ *
+ * @see _specifications/ccap-mirror/02-architecture-spec.md (J szakasz)
+ */
+export class DyFM_Error_Settings_ControlModel {
+    /** Display-only override a `source` mezőre (a runtime errorClientSource felülírja a UI-on). */
+    sourceLabelOverride;
+    /** Engedélyezi a `Copy to clipboard` gombot. Default: `true`. */
+    /** @deprecated Use isCopyEnabled; copyEnabled remains the serialized compatibility key. */
+    copyEnabled;
+    /** Engedélyezi a `Send to QuickInput` gombot (consumer-side QuickInput hub-bal). Default: `false`. */
+    /** @deprecated Use isSendToQuickInputEnabled; sendToQuickInputEnabled remains the serialized compatibility key. */
+    sendToQuickInputEnabled;
+    /** Mely szekciók legyenek **default expanded** (a többi collapsed indul). */
+    defaultExpandedSections;
+    /** Engedélyezi a `Show JSON` (raw error) shortcut-ot. Default: `false`. */
+    /** @deprecated Use isRawJsonShown; showRawJsonEnabled remains the serialized compatibility key. */
+    showRawJsonEnabled;
+    /** `data-testid` érték. */
+    testId;
+    constructor(set = {}) {
+        Object.assign(this, set);
+    }
+}
+Object.defineProperty(DyFM_Error_Settings_ControlModel, 'name', { value: 'DyFM_ErrorDisplay_Settings' });
+/** @deprecated Use DyFM_Error_Settings_ControlModel. Same constructor; no API removal. */
+export { DyFM_Error_Settings_ControlModel as DyFM_ErrorDisplay_Settings };
+Object.defineProperty(DyFM_Error_Settings_ControlModel.prototype, 'isCopyEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.copyEnabled;
+    },
+    set: function (isValue) {
+        this.copyEnabled = isValue;
+    },
+});
+Object.defineProperty(DyFM_Error_Settings_ControlModel.prototype, 'isSendToQuickInputEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.sendToQuickInputEnabled;
+    },
+    set: function (isValue) {
+        this.sendToQuickInputEnabled = isValue;
+    },
+});
+Object.defineProperty(DyFM_Error_Settings_ControlModel.prototype, 'isRawJsonShown', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.showRawJsonEnabled;
+    },
+    set: function (isValue) {
+        this.showRawJsonEnabled = isValue;
+    },
+});

package/build-esm/_modules/ngx-models/_models/control-models/errors/errors-settings.control-model.js

@@ -0,0 +1,52 @@
+/**
+ * CCAP-mirror Wave-1a — Global errors-service Settings.
+ *
+ * A `DyNX_Errors_ControlService` (FR-029 mirror) konfigurációja. Server-importálható
+ * POJO. A konzument LIVE-projekt build-time vagy bootstrap-en pédányosítja és
+ * provider-en át DI-zza a service-be.
+ *
+ * @see _specifications/ccap-mirror/02-architecture-spec.md (J szakasz)
+ */
+export class DyFM_Errors_Settings_ControlModel {
+    /** Konzument backend error-endpoint (HTTP POST cél). Default: `'/errors/log'`. */
+    reportEndpoint;
+    /** Loop-detection csúszó-ablak (ms). Default: 3000. */
+    loopThresholdMs;
+    /** Loop-detection küszöb: ennyi same-stack ezalatt → throttle. Default: 5. */
+    loopRepeatCount;
+    /** Storm-protection: ennyi error ezalatt → suppress all. Default: 50. */
+    stormThresholdPerWindow;
+    /** Storm-protection csúszó-ablak (ms). Default: 10000. */
+    stormWindowMs;
+    /** Popup-dedup ablak (same-error popup throttle, ms). Default: 10000. */
+    popupDedupMs;
+    /** UI mode: popup (modal-on-error) | bubble (CCAP-stack) | both. Default: `bubble`. */
+    uiMode;
+    /** Bubble-stack maximális hossza. Default: 10. */
+    notificationStackMax;
+    /** Auto-dismiss timeout (ms) bubble-ökhöz. Default: 10000. */
+    autoDismissMs;
+    /** Riportálja-e a socket-transport (connect/disconnect) error-okat is. Default: false. */
+    /** @deprecated Use isSocketConnectionErrorReportingEnabled; reportSocketConnectionErrors remains the serialized compatibility key. */
+    reportSocketConnectionErrors;
+    /** Auto-recover storm-mode utáni silence (ms). Default: 30000. */
+    stormRecoverSilenceMs;
+    /** `data-testid` (parent érték; child komponensek hozzáfűzik a sub-id-t). */
+    testId;
+    constructor(set = {}) {
+        Object.assign(this, set);
+    }
+}
+Object.defineProperty(DyFM_Errors_Settings_ControlModel, 'name', { value: 'DyFM_Errors_Settings' });
+/** @deprecated Use DyFM_Errors_Settings_ControlModel. Same constructor; no API removal. */
+export { DyFM_Errors_Settings_ControlModel as DyFM_Errors_Settings };
+Object.defineProperty(DyFM_Errors_Settings_ControlModel.prototype, 'isSocketConnectionErrorReportingEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.reportSocketConnectionErrors;
+    },
+    set: function (isValue) {
+        this.reportSocketConnectionErrors = isValue;
+    },
+});