@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_modules/data-handler/_models/data-handler-settings.control-model.d.ts

@@ -1,73 +1,73 @@
-import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
-import { DyFM_SearchQuery } from '../../../_models/interfaces/search-query.interface';
-import { DyFM_DataHandler, DyFM_DataHandlerDataLoadPostProcess } from './data-handler.control-model';
-/**
- * DyFM_DataHandler_Settings
- * @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',
- * });
- */
-export declare class DyFM_DataHandler_Settings<T extends DyFM_Metadata | DyFM_Metadata[], T_Dependency extends DyFM_Metadata = any, T_LoadBy = string> {
-    name?: string;
-    /** this will be used to get the data from the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    get?: (loadBy?: T_LoadBy) => Promise<any>;
-    /** this will be used to set the data to the data handler
-     * while creating arrow function for this, dont forget to use async n await! */
-    set?: (data: T) => Promise<T>;
-    /**
-     * 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)
-     */
-    getPostProcess?: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>;
-    dependencyDataHandler?: DyFM_DataHandler<T_Dependency>;
-    dependentDataHandlers?: DyFM_DataHandler<any>[];
-    defaultValue?: T;
-    defaultLoadBy?: T_LoadBy;
-    noId?: boolean;
-    debugLog?: boolean;
-}
-/**
- * DyFM_DataListHandler_Settings
- */
-export declare class DyFM_DataListHandler_Settings<T_DataItem extends DyFM_Metadata, T_DependencyData extends DyFM_Metadata = any, T_DataLoadBy = string, T_UpdateItemBy = string> extends DyFM_DataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
-    /** this will be used to send the item update to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    setItem?: (item: T_DataItem, updateBy?: T_UpdateItemBy) => Promise<T_DataItem>;
-    /** this will be used to send the item delete to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    deleteItem?: (id: string, updateBy?: T_UpdateItemBy) => Promise<void>;
-}
-export declare class DyFM_DataSearchHandler_Settings<T_DataItem extends DyFM_Metadata, T_DataLoadBy extends DyFM_SearchQuery<any> = DyFM_SearchQuery<T_DataItem>, T_DependencyData extends DyFM_Metadata = any> extends DyFM_DataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
-    defaultQuery?: T_DataLoadBy;
-    defaultPageSize?: number;
-    cacheSize?: number;
-    queryUpdateDebounceTime?: number;
-    searchOnInit?: boolean;
-}
-export declare class DyFM_ListCollectorDataHandler_Settings<T_ListCollectorData extends DyFM_Metadata, T_DataItem extends DyFM_Metadata, T_DependencyData extends DyFM_Metadata = any, T_DataLoadBy = string> extends DyFM_DataHandler_Settings<T_ListCollectorData, T_DependencyData, T_DataLoadBy> {
-    /** this will be used to send the item update to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    setItem?: (item: T_DataItem, collectorId?: string) => Promise<T_DataItem>;
-    /** this will be used to send the item delete to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    deleteItem?: (id: string, collectorId?: string) => Promise<void>;
-    listKey: string;
-}
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+import { DyFM_SearchQuery } from '../../../_models/interfaces/search-query.interface';
+import { DyFM_DataHandler, DyFM_DataHandlerDataLoadPostProcess } from './data-handler.control-model';
+/**
+ * DyFM_DataHandler_Settings
+ * @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',
+ * });
+ */
+export declare class DyFM_DataHandler_Settings<T extends DyFM_Metadata | DyFM_Metadata[], T_Dependency extends DyFM_Metadata = any, T_LoadBy = string> {
+    name?: string;
+    /** this will be used to get the data from the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    get?: (loadBy?: T_LoadBy) => Promise<any>;
+    /** this will be used to set the data to the data handler
+     * while creating arrow function for this, dont forget to use async n await! */
+    set?: (data: T) => Promise<T>;
+    /**
+     * 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)
+     */
+    getPostProcess?: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>;
+    dependencyDataHandler?: DyFM_DataHandler<T_Dependency>;
+    dependentDataHandlers?: DyFM_DataHandler<any>[];
+    defaultValue?: T;
+    defaultLoadBy?: T_LoadBy;
+    noId?: boolean;
+    debugLog?: boolean;
+}
+/**
+ * DyFM_DataListHandler_Settings
+ */
+export declare class DyFM_DataListHandler_Settings<T_DataItem extends DyFM_Metadata, T_DependencyData extends DyFM_Metadata = any, T_DataLoadBy = string, T_UpdateItemBy = string> extends DyFM_DataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
+    /** this will be used to send the item update to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    setItem?: (item: T_DataItem, updateBy?: T_UpdateItemBy) => Promise<T_DataItem>;
+    /** this will be used to send the item delete to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    deleteItem?: (id: string, updateBy?: T_UpdateItemBy) => Promise<void>;
+}
+export declare class DyFM_DataSearchHandler_Settings<T_DataItem extends DyFM_Metadata, T_DataLoadBy extends DyFM_SearchQuery<any> = DyFM_SearchQuery<T_DataItem>, T_DependencyData extends DyFM_Metadata = any> extends DyFM_DataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
+    defaultQuery?: T_DataLoadBy;
+    defaultPageSize?: number;
+    cacheSize?: number;
+    queryUpdateDebounceTime?: number;
+    searchOnInit?: boolean;
+}
+export declare class DyFM_ListCollectorDataHandler_Settings<T_ListCollectorData extends DyFM_Metadata, T_DataItem extends DyFM_Metadata, T_DependencyData extends DyFM_Metadata = any, T_DataLoadBy = string> extends DyFM_DataHandler_Settings<T_ListCollectorData, T_DependencyData, T_DataLoadBy> {
+    /** this will be used to send the item update to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    setItem?: (item: T_DataItem, collectorId?: string) => Promise<T_DataItem>;
+    /** this will be used to send the item delete to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    deleteItem?: (id: string, collectorId?: string) => Promise<void>;
+    listKey: string;
+}
 //# sourceMappingURL=data-handler-settings.control-model.d.ts.map

package/build/_modules/data-handler/_models/data-handler-settings.control-model.js

@@ -1,83 +1,83 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_ListCollectorDataHandler_Settings = exports.DyFM_DataSearchHandler_Settings = exports.DyFM_DataListHandler_Settings = exports.DyFM_DataHandler_Settings = void 0;
-/**
- * DyFM_DataHandler_Settings
- * @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',
- * });
- */
-class DyFM_DataHandler_Settings {
-    name;
-    /** this will be used to get the data from the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    get;
-    /** this will be used to set the data to the data handler
-     * while creating arrow function for this, dont forget to use async n await! */
-    set;
-    /* patch?: (data: T) => Promise<T>; */
-    // TODO
-    /* directApiSetup?: { set, get,}; */
-    // AVAGY
-    /* apiCallSettings?: DyNX_ApiCall_Settings; */
-    /* successfulLoadCallBack?: (data: T) => void; */
-    /**
-     * 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)
-     */
-    getPostProcess;
-    dependencyDataHandler;
-    dependentDataHandlers;
-    defaultValue;
-    defaultLoadBy;
-    noId;
-    debugLog;
-}
-exports.DyFM_DataHandler_Settings = DyFM_DataHandler_Settings;
-/**
- * DyFM_DataListHandler_Settings
- */
-class DyFM_DataListHandler_Settings extends DyFM_DataHandler_Settings {
-    /** this will be used to send the item update to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    setItem;
-    /** this will be used to send the item delete to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    deleteItem;
-}
-exports.DyFM_DataListHandler_Settings = DyFM_DataListHandler_Settings;
-class DyFM_DataSearchHandler_Settings extends DyFM_DataHandler_Settings {
-    defaultQuery;
-    defaultPageSize;
-    cacheSize;
-    queryUpdateDebounceTime;
-    searchOnInit;
-}
-exports.DyFM_DataSearchHandler_Settings = DyFM_DataSearchHandler_Settings;
-class DyFM_ListCollectorDataHandler_Settings extends DyFM_DataHandler_Settings {
-    /** this will be used to send the item update to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    setItem;
-    /** this will be used to send the item delete to the API
-     * while creating arrow function for this, dont forget to use async n await! */
-    deleteItem;
-    listKey;
-}
-exports.DyFM_ListCollectorDataHandler_Settings = DyFM_ListCollectorDataHandler_Settings;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_ListCollectorDataHandler_Settings = exports.DyFM_DataSearchHandler_Settings = exports.DyFM_DataListHandler_Settings = exports.DyFM_DataHandler_Settings = void 0;
+/**
+ * DyFM_DataHandler_Settings
+ * @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',
+ * });
+ */
+class DyFM_DataHandler_Settings {
+    name;
+    /** this will be used to get the data from the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    get;
+    /** this will be used to set the data to the data handler
+     * while creating arrow function for this, dont forget to use async n await! */
+    set;
+    /* patch?: (data: T) => Promise<T>; */
+    // TODO
+    /* directApiSetup?: { set, get,}; */
+    // AVAGY
+    /* apiCallSettings?: DyNX_ApiCall_Settings; */
+    /* successfulLoadCallBack?: (data: T) => void; */
+    /**
+     * 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)
+     */
+    getPostProcess;
+    dependencyDataHandler;
+    dependentDataHandlers;
+    defaultValue;
+    defaultLoadBy;
+    noId;
+    debugLog;
+}
+exports.DyFM_DataHandler_Settings = DyFM_DataHandler_Settings;
+/**
+ * DyFM_DataListHandler_Settings
+ */
+class DyFM_DataListHandler_Settings extends DyFM_DataHandler_Settings {
+    /** this will be used to send the item update to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    setItem;
+    /** this will be used to send the item delete to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    deleteItem;
+}
+exports.DyFM_DataListHandler_Settings = DyFM_DataListHandler_Settings;
+class DyFM_DataSearchHandler_Settings extends DyFM_DataHandler_Settings {
+    defaultQuery;
+    defaultPageSize;
+    cacheSize;
+    queryUpdateDebounceTime;
+    searchOnInit;
+}
+exports.DyFM_DataSearchHandler_Settings = DyFM_DataSearchHandler_Settings;
+class DyFM_ListCollectorDataHandler_Settings extends DyFM_DataHandler_Settings {
+    /** this will be used to send the item update to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    setItem;
+    /** this will be used to send the item delete to the API
+     * while creating arrow function for this, dont forget to use async n await! */
+    deleteItem;
+    listKey;
+}
+exports.DyFM_ListCollectorDataHandler_Settings = DyFM_ListCollectorDataHandler_Settings;
 //# sourceMappingURL=data-handler-settings.control-model.js.map

package/build/_modules/data-handler/_models/data-handler.control-model.d.ts

@@ -1,149 +1,149 @@
-import { DyFM_Metadata } from '../../..';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
-/**
- * DyFM_DataHandlerDataLoadInProgress
- */
-export interface DyFM_DataHandlerDataLoadInProgress<T_LoadBy> {
-    loadBy: T_LoadBy;
-    progress: Promise<any>;
-}
-/**
- * DyFM_DataHandlerDataPostProcess
- */
-export type DyFM_DataHandlerDataLoadPostProcess<T_LoadBy> = (data: any, loadedBy: T_LoadBy) => Promise<any> | any;
-/**
- * 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',
- * });
- */
-export declare abstract class DyFM_DataHandler<T extends DyFM_Metadata | DyFM_Metadata[], T_Dependency extends DyFM_Metadata = any, T_LoadBy = string> {
-    name: string;
-    /**
-     * BehaviorSubject that holds the current data value.
-     * This is the source of truth for data in DyFM.
-     */
-    protected readonly data_BS: BehaviorSubject<T>;
-    /**
-     * Observable that emits the current data value.
-     * Derived from the BehaviorSubject.
-     */
-    readonly data$: Observable<T>;
-    /**
-     * BehaviorSubject that indicates whether the data has been loaded.
-     * True when data is loaded, false otherwise.
-     */
-    protected readonly loaded_BS: BehaviorSubject<boolean>;
-    /**
-     * Observable that indicates whether the data has been loaded.
-     */
-    readonly loaded$: Observable<boolean>;
-    /**
-     * BehaviorSubject that tracks the current loading operation.
-     * Contains information about the ongoing data load operation or false if no load is in progress.
-     */
-    protected readonly loadInProgress_BS: BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
-    /**
-     * Observable that tracks the current loading operation.
-     */
-    readonly loadInProgress$: Observable<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
-    /**
-     * Gets the current data value.
-     * @returns The current data value
-     */
-    abstract get data(): T;
-    /**
-     * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
-     */
-    lastLoadedBy: T_LoadBy;
-    defaultLoadBy: T_LoadBy;
-    /** this will handle the data loading from the api */
-    protected readonly get: (loadBy?: T_LoadBy) => Promise<any>;
-    /** this will handle the data setting to the data handler */
-    protected readonly set: (data: T) => Promise<T>;
-    /** this will handle the data patching to the data handler */
-    /**
-     * 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)
-     */
-    protected readonly getPostProcesses: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>[];
-    noId?: boolean;
-    waitsOnLoad: {
-        promise: Promise<void>;
-        resolve: () => void;
-    }[];
-    protected readonly dependentDataHandlers?: DyFM_DataHandler<any>[];
-    debugLog?: boolean;
-    /**
-     * 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: DyFM_DataHandler_Settings<T, T_Dependency, T_LoadBy>, 
-    /** is in construct?
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections?: boolean);
-    addDependencyDataHandler(dependencyDataHandler: DyFM_DataHandler<any>): void;
-    addDependentDataHandlers(dependentDataHandlers: DyFM_DataHandler<any, any, any>[], isInConstruct?: boolean): void;
-    /**
-     * 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 })
-     * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
-     */
-    reloadData(loadBy?: T_LoadBy, opts?: {
-        silentMissingId?: boolean;
-    }): Promise<T>;
-    getData(): Promise<T>;
-    protected doReloadDataBy(loadedBy: T_LoadBy): Promise<T>;
-    /**
-     * A DataHandler adatának közvetlen frissítése egy már ismert value-val, szerver-round-trip NÉLKÜL
-     * (pl. login-response → user_DH.updateData). Alapból CSAK a saját data_BS-t frissíti.
-     *
-     * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a `reloadData` post-process
-     *   dependent-reload-láncát is meghajtja — a függő DataHandler-ek (pl. token-balance) újratöltődnek
-     *   az új adat `_id`-jével. A `reloadData` (hard-nav boot) útján ez a lánc automatikus, de az
-     *   `updateData` (round-trip-mentes) útján eddig NEM futott → a friss SPA-login után a dependent-DH
-     *   adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe): az `updateData` fő szándéka
-     *   ÉPP a szerver-hívás elkerülése, ezért a vak dependent-reload nem kívánt HTTP-flood-ot okozhatna.
-     */
-    updateData(data: T, dontSendUpdate?: boolean, reloadDependents?: boolean): Promise<void>;
-    clear(dontClearDependents?: boolean): void;
-    protected processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T>;
-    private resolveWaitsOnLoad;
-    /**
-     * waits for the first load to finish
-     * @returns a promise that resolves when the first load finishes after this "subscription"
-     */
-    waitForLoad(): Promise<void>;
-}
+import { DyFM_Metadata } from '../../..';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
+/**
+ * DyFM_DataHandlerDataLoadInProgress
+ */
+export interface DyFM_DataHandlerDataLoadInProgress<T_LoadBy> {
+    loadBy: T_LoadBy;
+    progress: Promise<any>;
+}
+/**
+ * DyFM_DataHandlerDataPostProcess
+ */
+export type DyFM_DataHandlerDataLoadPostProcess<T_LoadBy> = (data: any, loadedBy: T_LoadBy) => Promise<any> | any;
+/**
+ * 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',
+ * });
+ */
+export declare abstract class DyFM_DataHandler<T extends DyFM_Metadata | DyFM_Metadata[], T_Dependency extends DyFM_Metadata = any, T_LoadBy = string> {
+    name: string;
+    /**
+     * BehaviorSubject that holds the current data value.
+     * This is the source of truth for data in DyFM.
+     */
+    protected readonly data_BS: BehaviorSubject<T>;
+    /**
+     * Observable that emits the current data value.
+     * Derived from the BehaviorSubject.
+     */
+    readonly data$: Observable<T>;
+    /**
+     * BehaviorSubject that indicates whether the data has been loaded.
+     * True when data is loaded, false otherwise.
+     */
+    protected readonly loaded_BS: BehaviorSubject<boolean>;
+    /**
+     * Observable that indicates whether the data has been loaded.
+     */
+    readonly loaded$: Observable<boolean>;
+    /**
+     * BehaviorSubject that tracks the current loading operation.
+     * Contains information about the ongoing data load operation or false if no load is in progress.
+     */
+    protected readonly loadInProgress_BS: BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
+    /**
+     * Observable that tracks the current loading operation.
+     */
+    readonly loadInProgress$: Observable<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
+    /**
+     * Gets the current data value.
+     * @returns The current data value
+     */
+    abstract get data(): T;
+    /**
+     * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
+     */
+    lastLoadedBy: T_LoadBy;
+    defaultLoadBy: T_LoadBy;
+    /** this will handle the data loading from the api */
+    protected readonly get: (loadBy?: T_LoadBy) => Promise<any>;
+    /** this will handle the data setting to the data handler */
+    protected readonly set: (data: T) => Promise<T>;
+    /** this will handle the data patching to the data handler */
+    /**
+     * 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)
+     */
+    protected readonly getPostProcesses: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>[];
+    noId?: boolean;
+    waitsOnLoad: {
+        promise: Promise<void>;
+        resolve: () => void;
+    }[];
+    protected readonly dependentDataHandlers?: DyFM_DataHandler<any>[];
+    debugLog?: boolean;
+    /**
+     * 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: DyFM_DataHandler_Settings<T, T_Dependency, T_LoadBy>, 
+    /** is in construct?
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections?: boolean);
+    addDependencyDataHandler(dependencyDataHandler: DyFM_DataHandler<any>): void;
+    addDependentDataHandlers(dependentDataHandlers: DyFM_DataHandler<any, any, any>[], isInConstruct?: boolean): void;
+    /**
+     * 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 })
+     * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
+     */
+    reloadData(loadBy?: T_LoadBy, opts?: {
+        silentMissingId?: boolean;
+    }): Promise<T>;
+    getData(): Promise<T>;
+    protected doReloadDataBy(loadedBy: T_LoadBy): Promise<T>;
+    /**
+     * A DataHandler adatának közvetlen frissítése egy már ismert value-val, szerver-round-trip NÉLKÜL
+     * (pl. login-response → user_DH.updateData). Alapból CSAK a saját data_BS-t frissíti.
+     *
+     * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a `reloadData` post-process
+     *   dependent-reload-láncát is meghajtja — a függő DataHandler-ek (pl. token-balance) újratöltődnek
+     *   az új adat `_id`-jével. A `reloadData` (hard-nav boot) útján ez a lánc automatikus, de az
+     *   `updateData` (round-trip-mentes) útján eddig NEM futott → a friss SPA-login után a dependent-DH
+     *   adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe): az `updateData` fő szándéka
+     *   ÉPP a szerver-hívás elkerülése, ezért a vak dependent-reload nem kívánt HTTP-flood-ot okozhatna.
+     */
+    updateData(data: T, dontSendUpdate?: boolean, reloadDependents?: boolean): Promise<void>;
+    clear(dontClearDependents?: boolean): void;
+    protected processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T>;
+    private resolveWaitsOnLoad;
+    /**
+     * waits for the first load to finish
+     * @returns a promise that resolves when the first load finishes after this "subscription"
+     */
+    waitForLoad(): Promise<void>;
+}
 //# sourceMappingURL=data-handler.control-model.d.ts.map