react-dialogger 1.1.48 → 1.1.50

package/helpers/index.d.ts

@@ -1,2 +1,3 @@
 export { InitDialogMemoizeBounds, InitDialogMemoizeBoundsDeclared, registeredDialogs } from "./initDialogMemoizeBounds";
 export * from "./dialogBoundsMemoize";
+export { formInputKeyListeners } from "./formInputKeyListeners";

package/helpers/index.js

@@ -14,9 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registeredDialogs = exports.InitDialogMemoizeBoundsDeclared = exports.InitDialogMemoizeBounds = void 0;
+exports.formInputKeyListeners = exports.registeredDialogs = exports.InitDialogMemoizeBoundsDeclared = exports.InitDialogMemoizeBounds = void 0;
 var initDialogMemoizeBounds_1 = require("./initDialogMemoizeBounds");
 Object.defineProperty(exports, "InitDialogMemoizeBounds", { enumerable: true, get: function () { return initDialogMemoizeBounds_1.InitDialogMemoizeBounds; } });
 Object.defineProperty(exports, "InitDialogMemoizeBoundsDeclared", { enumerable: true, get: function () { return initDialogMemoizeBounds_1.InitDialogMemoizeBoundsDeclared; } });
 Object.defineProperty(exports, "registeredDialogs", { enumerable: true, get: function () { return initDialogMemoizeBounds_1.registeredDialogs; } });
 __exportStar(require("./dialogBoundsMemoize"), exports);
+var formInputKeyListeners_1 = require("./formInputKeyListeners");
+Object.defineProperty(exports, "formInputKeyListeners", { enumerable: true, get: function () { return formInputKeyListeners_1.formInputKeyListeners; } });

package/helpers/initDialogMemoizeBounds.d.ts

@@ -1,5 +1,10 @@
-import { IDialogBoundDef, IDialogBoundsMemoKey } from "./BoundTypes";
-export declare let registeredDialogs: IDialogBoundDef[];
+import { IDialogBoundsMemoKey, RegisteredDialogsMap } from "../types/BoundTypes";
+export declare let registeredDialogs: RegisteredDialogsMap;
 export declare let InitDialogMemoizeBoundsDeclared: boolean;
 export declare const BOUNDS_STORE_KEY: IDialogBoundsMemoKey;
+/**
+ * Fire by first load the page
+ * This should be in App level
+ * Create first records
+ * */
 export declare const InitDialogMemoizeBounds: () => void;

package/helpers/initDialogMemoizeBounds.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitDialogMemoizeBounds = exports.BOUNDS_STORE_KEY = exports.InitDialogMemoizeBoundsDeclared = exports.registeredDialogs = void 0;
-// Sayfa ilk yuklendiginde calisacak
-exports.registeredDialogs = [];
+// export let registeredDialogs: IDialogBoundDef[] = [];
+exports.registeredDialogs = new Map();
 exports.InitDialogMemoizeBoundsDeclared = false;
 exports.BOUNDS_STORE_KEY = 'react-super-dialog';
-// Bu App level sevyesinde olmali
-// ILk Kayitlari olusturuyoruz
+/**
+ * Fire by first load the page
+ * This should be in App level
+ * Create first records
+ * */
 var InitDialogMemoizeBounds = function () {
     var boundStoreExists = function () {
         try {
@@ -17,22 +20,24 @@ var InitDialogMemoizeBounds = function () {
         }
     };
     var createBoundStore = function () {
-        if (!boundStoreExists()) {
-            try {
-                window.localStorage.setItem(exports.BOUNDS_STORE_KEY, JSON.stringify([]));
-            }
-            catch (e) {
-                console.log(e);
-            }
+        try {
+            window.localStorage.setItem(exports.BOUNDS_STORE_KEY, JSON.stringify([]));
+        }
+        catch (e) {
+            console.log(e);
         }
     };
     var readFromStore = function () {
-        createBoundStore();
+        if (!boundStoreExists) {
+            createBoundStore();
+        }
         var boundsRaw = window.localStorage.getItem(exports.BOUNDS_STORE_KEY);
+        // console.log('boundsRaw', boundStoreExists, JSON.parse(boundsRaw));
         var boundsArray = boundsRaw ? JSON.parse(boundsRaw) : [];
-        return boundsArray;
+        console.log('readFromStore-0', boundsArray);
+        return new Map(boundsArray.map(function (d) { return [d[0], d[1]]; }));
     };
-    console.log('readFromStore', readFromStore());
+    console.log('readFromStore', window.localStorage.getItem(exports.BOUNDS_STORE_KEY), readFromStore());
     // Set this on App level
     exports.registeredDialogs = readFromStore();
     exports.InitDialogMemoizeBoundsDeclared = true;

package/index.d.ts

@@ -1,9 +1,8 @@
 import './styles/dialog.scss';
 import './styles/dialog.action.scss';
 import './styles/circular-progress.scss';
-export { default as Dialog } from "./models/Dialog";
 export { default } from "./models/Dialog";
-export { DialogProcessing, DialogCloseAction, DialogFullscreenAction, DialogHeaderActionsWrapper, DialogInfoAction } from "./components/Futures";
-export { DialogAction, ActionProgress } from "./models/DialogAction";
-export { useDialogOptions } from "./hooks/useDialogOptions";
+export { DialogProcessing, DialogCloseAction, DialogFullscreenAction, DialogHeaderActionsWrapper, DialogInfoAction } from "./components/Features";
+export { DialogAction, ActionProgress, baseDialogOptions } from "./models";
 export { InitDialogMemoizeBounds } from "./helpers/initDialogMemoizeBounds";
+export { IDialogApiDef } from './types/DialogTypes';

package/index.js

@@ -3,26 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InitDialogMemoizeBounds = exports.useDialogOptions = exports.ActionProgress = exports.DialogAction = exports.DialogInfoAction = exports.DialogHeaderActionsWrapper = exports.DialogFullscreenAction = exports.DialogCloseAction = exports.DialogProcessing = exports.default = exports.Dialog = void 0;
+exports.InitDialogMemoizeBounds = exports.baseDialogOptions = exports.ActionProgress = exports.DialogAction = exports.DialogInfoAction = exports.DialogHeaderActionsWrapper = exports.DialogFullscreenAction = exports.DialogCloseAction = exports.DialogProcessing = exports.default = void 0;
 require("./styles/dialog.css");
 require("./styles/dialog.action.css");
 require("./styles/circular-progress.css");
 // Models
 var Dialog_1 = require("./models/Dialog");
-Object.defineProperty(exports, "Dialog", { enumerable: true, get: function () { return __importDefault(Dialog_1).default; } });
-var Dialog_2 = require("./models/Dialog");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Dialog_2).default; } });
-var Futures_1 = require("./components/Futures");
-Object.defineProperty(exports, "DialogProcessing", { enumerable: true, get: function () { return Futures_1.DialogProcessing; } });
-Object.defineProperty(exports, "DialogCloseAction", { enumerable: true, get: function () { return Futures_1.DialogCloseAction; } });
-Object.defineProperty(exports, "DialogFullscreenAction", { enumerable: true, get: function () { return Futures_1.DialogFullscreenAction; } });
-Object.defineProperty(exports, "DialogHeaderActionsWrapper", { enumerable: true, get: function () { return Futures_1.DialogHeaderActionsWrapper; } });
-Object.defineProperty(exports, "DialogInfoAction", { enumerable: true, get: function () { return Futures_1.DialogInfoAction; } });
-var DialogAction_1 = require("./models/DialogAction");
-Object.defineProperty(exports, "DialogAction", { enumerable: true, get: function () { return DialogAction_1.DialogAction; } });
-Object.defineProperty(exports, "ActionProgress", { enumerable: true, get: function () { return DialogAction_1.ActionProgress; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Dialog_1).default; } });
+var Features_1 = require("./components/Features");
+Object.defineProperty(exports, "DialogProcessing", { enumerable: true, get: function () { return Features_1.DialogProcessing; } });
+Object.defineProperty(exports, "DialogCloseAction", { enumerable: true, get: function () { return Features_1.DialogCloseAction; } });
+Object.defineProperty(exports, "DialogFullscreenAction", { enumerable: true, get: function () { return Features_1.DialogFullscreenAction; } });
+Object.defineProperty(exports, "DialogHeaderActionsWrapper", { enumerable: true, get: function () { return Features_1.DialogHeaderActionsWrapper; } });
+Object.defineProperty(exports, "DialogInfoAction", { enumerable: true, get: function () { return Features_1.DialogInfoAction; } });
+var models_1 = require("./models");
+Object.defineProperty(exports, "DialogAction", { enumerable: true, get: function () { return models_1.DialogAction; } });
+Object.defineProperty(exports, "ActionProgress", { enumerable: true, get: function () { return models_1.ActionProgress; } });
+Object.defineProperty(exports, "baseDialogOptions", { enumerable: true, get: function () { return models_1.baseDialogOptions; } });
 // Hooks
-var useDialogOptions_1 = require("./hooks/useDialogOptions");
-Object.defineProperty(exports, "useDialogOptions", { enumerable: true, get: function () { return useDialogOptions_1.useDialogOptions; } });
 var initDialogMemoizeBounds_1 = require("./helpers/initDialogMemoizeBounds");
 Object.defineProperty(exports, "InitDialogMemoizeBounds", { enumerable: true, get: function () { return initDialogMemoizeBounds_1.InitDialogMemoizeBounds; } });

package/models/Dialog.d.ts

@@ -1,47 +1,42 @@
 import * as React from "react";
 import { DialogAction } from "./DialogAction";
-import DialogBase from "../components/DialogBase";
-import { TInitialHolder, TAccessFrom, ComponentOrderPositions, ISnackbarAnchor, DialogValues } from "../types/types";
-import { IDialogSize, TDialogStateListenerCallbackType, DialogOptionsType, IDialogDef, TDialogCallbackNodeFn, TDialogCallbackVoidFn } from "../types/DialogTypes";
-import { FormikProps } from "formik";
-declare class Dialog extends DialogBase<any> {
-    constructor(dialogRef?: React.RefObject<IDialogDef | undefined | null> | null, options?: DialogOptionsType);
-    /**
-     * @deprecated
-     * @see dialogOptions.snackbar.anchorOrigin */
-    snackbarAnchor(anchor?: ISnackbarAnchor): this;
-    set accessFrom(accessFrom: TAccessFrom);
-    get accessFrom(): TAccessFrom;
-    setHeader(header: TDialogCallbackNodeFn): this;
-    setBody(body: TDialogCallbackNodeFn): this;
-    setFormik(formik: FormikProps<any>): this;
+import { TInitialHolder, DialogValues } from "../types/types";
+import { IDialogSize, TDialogStateListenerCallbackType, DialogOptionsType, IDialogApiDef, TDialogCallbackVoidFn, TDialogCallbackFn } from "../types/DialogTypes";
+interface DialogProps {
+    setHeader(header: TDialogCallbackFn): Dialog;
+}
+declare class Dialog implements DialogProps {
+    private _processingListener;
+    private _stateListener;
+    private _keyboardListener;
+    private _resizeListener;
+    private _initialHolder;
+    private _header;
+    private _body;
+    private _actions;
+    private _dialogSize;
+    private readonly _dialogOptions?;
+    private _snackbarAnchor;
+    private _initialValues;
+    private _headerRef;
+    private readonly _apiRef;
+    private _onCloseCallback;
+    constructor(dialogRef?: React.RefObject<IDialogApiDef | undefined | null> | null, options?: DialogOptionsType);
+    setHeader(header: TDialogCallbackFn): this;
+    setBody(body: TDialogCallbackFn): this;
     addActions(actions: Array<DialogAction>): this;
     addAction(action: DialogAction): this;
     /**
      * Only from init */
     stateListener(listener: TDialogStateListenerCallbackType): this;
-    /** @deprecated use Dialog Options */
-    setSize: (size: IDialogSize) => this;
-    /**
-     * @deprecated
-     * @info Dialog ordering after of before Reference Dom Element
-     * This method is deprecated and will be removed in a future release.
-     * Please use an alternative approach for setting dialog ordering or layout.
-     * The dialog ordering functionality will be managed differently in future versions.
-     */
-    setOrder: (position: ComponentOrderPositions, component: HTMLElement) => this;
-    /**
-     * @deprecated
-     * @link initialValues */
-    initialState(state: {
-        [k: string]: any;
-    }): this;
+    processingListener(listener: (inProcess: boolean) => void): this;
     initialValues(values: DialogValues): this;
     initialHolder(holder: TInitialHolder): this;
-    getDom: () => HTMLDivElement;
+    keyboardListener(listener: (key: string, dialog: IDialogApiDef) => void): this;
+    resizeListener(listener: (size: IDialogSize, dialog: IDialogApiDef) => void): this;
     onClose(callback: TDialogCallbackVoidFn): this;
-    keyboardListener(listener: (key: string, dialog: IDialogDef) => void): this;
-    resizeListener(listener: (size: IDialogSize, dialog: IDialogDef) => void): this;
-    show: (callback?: TDialogCallbackVoidFn) => void;
+    private highestZ;
+    private createDom;
+    show(callback?: TDialogCallbackVoidFn): void;
 }
 export default Dialog;

package/models/Dialog.js

@@ -1,128 +1,122 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
     };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
     };
 })();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+var React = __importStar(require("react"));
 var DialogBase_1 = __importDefault(require("../components/DialogBase"));
-var Dialog = /** @class */ (function (_super) {
-    __extends(Dialog, _super);
-    // This property holds a callback function that listens to state changes within the dialog. It is used to track or respond to changes in dialog state.
-    // private _stateListener: TDialogStateListenerCallbackType;
-    // This property stores the initial state of the dialog, which could include default settings or values before any interactions.
-    // private _initialState: TBaseDialogState;
-    // private _initialValues: TInitialValues<any>;
-    // This property represents the initial holder of the dialog. It is used before the dialog is shown, typically to manage resources or prepare the dialog for display (like loading animations or initial data).
-    // private _initialHolder: TInitialHolder;
-    // This property indicates where the dialog is accessed from, such as from a button or menu item, providing context about its origin.
-    // private _accessFrom: TAccessFrom;
-    // This property refers to the DOM element that will represent the dialog container on the web page. It is a `div` element dynamically created when the dialog is displayed.
-    // private _dom: HTMLDivElement;
-    // This property holds a function to handle keyboard events. It listens for key presses and performs actions based on the key and the current state of the dialog.
-    // private _keyboardListener: (key: string, dialog: Dialog) => void;
-    // This is a React reference (`RefObject`) used to access the dialog instance or DOM element directly within React components. It provides a way to interact with the DOM element programmatically without triggering re-renders.
-    // private readonly _innerRef: React.RefObject<any>;
-    // initialValues = ( values: T ): this => {
-    //     this._initialValues = values;
-    //     return this;
-    // }
+var client_1 = require("react-dom/client");
+var Dialog = /** @class */ (function () {
     function Dialog(dialogRef, options) {
-        var _this = _super.call(this) || this;
-        /** @deprecated use Dialog Options */
-        _this.setSize = function (size) {
-            _this._dialogSize = size;
-            return _this;
+        var _this = this;
+        this._headerRef = React.createRef();
+        this.highestZ = function () {
+            var presentationElements = document.querySelectorAll('div[data-family="presentation"]');
+            var highest = 1201;
+            presentationElements.forEach(function (element) {
+                var z = parseInt(window.getComputedStyle(element).zIndex, 10);
+                if (!isNaN(z) && z > highest) {
+                    highest = z;
+                }
+            });
+            return highest + 1;
         };
-        /**
-         * @deprecated
-         * @info Dialog ordering after of before Reference Dom Element
-         * This method is deprecated and will be removed in a future release.
-         * Please use an alternative approach for setting dialog ordering or layout.
-         * The dialog ordering functionality will be managed differently in future versions.
-         */
-        _this.setOrder = function (position, component) {
-            _this._order = { position: position, dom: component };
-            return _this;
-        };
-        _this.getDom = function () {
-            return _this._dom;
-        };
-        _this.show = function (callback) {
-            _super.prototype.show.call(_this, callback);
+        this.createDom = function () {
+            console.log('this._actions', _this._actions);
+            var dom = document.createElement('div');
+            dom.setAttribute('role', 'presentation');
+            dom.setAttribute('data-type', 'dialog');
+            dom.setAttribute('data-family', 'presentation');
+            dom.classList.add('react-guzzle-root');
+            dom.style.setProperty('z-index', String(_this.highestZ()));
+            // Find root element
+            var rootElement = document.getElementById('root');
+            // const AppElement = rootElement.firstElementChild;
+            if (rootElement) {
+                rootElement.appendChild(dom);
+                // AppElement.prepend(this._dom);
+            }
+            else {
+                document.body.appendChild(dom);
+            }
+            return dom;
         };
         if (dialogRef) {
-            _this._innerRef = dialogRef;
+            this._apiRef = dialogRef;
         }
         if (options) {
-            _this._dialogOptions = options;
+            this._dialogOptions = options;
         }
-        return _this;
     }
-    /**
-     * @deprecated
-     * @see dialogOptions.snackbar.anchorOrigin */
-    Dialog.prototype.snackbarAnchor = function (anchor) {
-        this._snackbarAnchor = anchor;
-        return this;
-    };
-    Object.defineProperty(Dialog.prototype, "accessFrom", {
-        get: function () {
-            return this._accessFrom;
-        },
-        set: function (accessFrom) {
-            this._accessFrom = accessFrom;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Dialog.prototype.setHeader = function (header) {
-        _super.prototype.setHeader.call(this, header);
+        this._header = header;
         return this;
     };
-    // setBody = ( body: CallbackFn['NodeFn'] ): Dialog => {
     Dialog.prototype.setBody = function (body) {
-        _super.prototype.setBody.call(this, body);
-        return this;
-    };
-    Dialog.prototype.setFormik = function (formik) {
-        this.formikProps = formik;
+        this._body = body;
         return this;
     };
     Dialog.prototype.addActions = function (actions) {
-        _super.prototype.addActions.call(this, actions); // overrided
+        this._actions = actions;
         return this;
     };
     Dialog.prototype.addAction = function (action) {
-        _super.prototype.addAction.call(this, action);
+        this._actions.push(action);
         return this;
     };
     /**
      * Only from init */
     Dialog.prototype.stateListener = function (listener) {
-        _super.prototype.stateListener.call(this, listener);
+        this._stateListener = listener;
         return this;
     };
-    /**
-     * @deprecated
-     * @link initialValues */
-    // initialState = ( state: TBaseDialogState ): this => {
-    Dialog.prototype.initialState = function (state) {
-        console.warn('Dialog Warning', 'initialState not more supported, replace this with initialValues');
-        this._initialState = state;
+    Dialog.prototype.processingListener = function (listener) {
+        // @ts-ignore
+        this._processingListener = listener;
         return this;
     };
     Dialog.prototype.initialValues = function (values) {
@@ -130,21 +124,40 @@ var Dialog = /** @class */ (function (_super) {
         return this;
     };
     Dialog.prototype.initialHolder = function (holder) {
-        _super.prototype.initialHolder.call(this, holder);
-        return this;
-    };
-    Dialog.prototype.onClose = function (callback) {
-        _super.prototype.onClose.call(this, callback);
+        this._initialHolder = holder;
         return this;
     };
     Dialog.prototype.keyboardListener = function (listener) {
-        _super.prototype.keyboardListener.call(this, listener); // overrided and return current dialog instance directly
+        this._keyboardListener = listener;
         return this;
     };
     Dialog.prototype.resizeListener = function (listener) {
-        _super.prototype.resizeListener.call(this, listener);
+        this._resizeListener = listener;
         return this;
     };
+    Dialog.prototype.onClose = function (callback) {
+        this._onCloseCallback = callback;
+        return this;
+    };
+    Dialog.prototype.show = function (callback) {
+        var dom = this.createDom();
+        var root = (0, client_1.createRoot)(dom);
+        var props = __assign(__assign({ 
+            // Initials
+            initialOptions: this._dialogOptions, initialValues: this._initialValues, didMountCallback: callback, 
+            // Component contents
+            header: this._header, body: this._body, actions: this._actions, 
+            // Refs
+            headerRef: this._headerRef, 
+            // Listeners
+            stateListener: this._stateListener, keyboardListener: this._keyboardListener, resizeListener: this._resizeListener, 
+            // Others
+            dialogSize: this._dialogSize, initialHolder: this._initialHolder, snackbarAnchor: this._snackbarAnchor, root: root, dom: dom, parent: this }, this._apiRef ? { ref: this._apiRef } : null), { onClose: this._onCloseCallback });
+        // @ts-ignore
+        root.render(React.createElement(DialogBase_1.default, props));
+    };
     return Dialog;
-}(DialogBase_1.default));
+}());
 exports.default = Dialog;
+// const dialog = new Dialog();
+// dialog.

package/models/DialogAction.d.ts

@@ -1,4 +1,4 @@
-import { TDialogStateListenerForActionCallbackType, DialogActionOptionsType, TBVariant, TBColor, ActionProps, DialogActionType } from "../types/DialogActionTypes";
+import { TDialogStateListenerForActionCallbackType, DialogActionOptionsType, DialogActionType } from "../types/DialogActionTypes";
 import DialogActionBase from "../components/DialogActionBase";
 declare const ActionProgress: () => import("react/jsx-runtime").JSX.Element;
 export { ActionProgress };
@@ -7,47 +7,9 @@ declare class DialogAction extends DialogActionBase {
     setOptions: (options: DialogActionOptionsType) => this;
     get options(): DialogActionOptionsType;
     get name(): string;
-    /**
-     * @deprecated
-     * @see DialogActionOptionsType
-     * @info Define this prop inside new DialogAction('varName', {>here<})*/
-    setLabel: (label: string) => DialogAction;
-    getLabel: () => string;
     onClick: (callback: DialogActionType) => this;
-    /**
-     * @deprecated
-     * @see onClickHandler */
-    getAction(): DialogActionType;
-    /**
-     * @deprecated
-     * @see DialogActionOptionsType
-     * @info Define this prop inside new DialogAction('varName', {>here<})*/
-    setVariant: (variant: TBVariant) => this;
-    getVariant: () => TBVariant;
-    /**
-     * @deprecated
-     * @see DialogActionOptionsType
-     * @info Define this prop inside new DialogAction('varName', {>here<})*/
-    setColor: (color: TBColor) => this;
-    getColor: () => TBColor;
     /**
      * Only from init */
     stateListener: (listener: TDialogStateListenerForActionCallbackType) => this;
-    set baseDialogAction(baseDialogAction: DialogActionBase);
-    setInProcess: (inProcess: ActionProps["inProcess"]) => this;
-    /**
-     * @deprecated
-     * @see isInProcess*/
-    getInProcess: () => boolean;
-    isInProcess: () => boolean;
-    /**
-     * @deprecated
-     * @see DialogActionOptionsType
-     * @info Define this prop inside new DialogAction('varName', {>here<})*/
-    setDisabled: (disabled: boolean) => this;
-    getDisabled: () => boolean;
-    isDisabled: () => boolean;
-    remove: () => void;
-    click: () => void;
 }
 export { DialogAction };