@m4l/components 0.2.35 → 1.0.0

package/components/DataGrid/subcomponents/editors/TextEditor/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { EditorProps } from 'react-data-grid';
+export declare const Input: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, {}>;
+export declare function TextEditor<TRow, TSummaryRow>({ row, column, onRowChange, onClose, }: EditorProps<TRow, TSummaryRow>): import("react/jsx-runtime").JSX.Element;
+export declare function NumberEditor<TRow, TSummaryRow>({ row, column, onRowChange, onClose, }: EditorProps<TRow, TSummaryRow>): import("react/jsx-runtime").JSX.Element;
+export default TextEditor;

package/components/DragResizeWindow/DragResizeWindow.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+/// <reference types="react" />
 import type { DraggableWindowProps, DraggableWindowRefProps } from './types';
 /**
  * Este component es un wrapper o ventana draggable y resizeable al children.
@@ -13,9 +13,9 @@ import type { DraggableWindowProps, DraggableWindowRefProps } from './types';
  *     Por lo tanto todo el estilo, va directamente a WrapperWindowRoot.
  * Consideraciones:
  *
- 
+
  * @param props
  * @returns
  */
-export declare const DragResizeWindow: React.ForwardRefExoticComponent<DraggableWindowProps & React.RefAttributes<DraggableWindowRefProps>>;
+export declare const DragResizeWindow: import("react").ForwardRefExoticComponent<DraggableWindowProps & import("react").RefAttributes<DraggableWindowRefProps>>;
 export default DragResizeWindow;

package/components/DragResizeWindow/classes/types.d.ts

@@ -1,4 +1,4 @@
-import { draggableWindowUtilityClasses } from ".";
+import { draggableWindowUtilityClasses } from '.';
 export interface DraggableWindowClasses {
     root: string;
     draggableHandle: string;

package/components/DragResizeWindow/index.46b380e1.js

@@ -0,0 +1,477 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef, useState, useRef, useImperativeHandle, useCallback, useEffect, useMemo } from "react";
+import { D as DraggableCore_1 } from "../../react-draggable.5331add7.js";
+import clsx from "clsx";
+import { styled, generateUtilityClasses } from "@mui/material";
+import { M as MAP_ZINDEX_OVER_MAP, C as COMPONENT_CLASS_NAME, D as DEFAULT_TRANSFORM_SCALE, a as MAP_ZINDEX_OVER_MAP$1 } from "../areas/constants.5387d83e.js";
+import "@mui/base";
+import { R as Resizable } from "../../react-resizable.37bfb965.js";
+const WrapperWindowRoot = styled("div")`
+  position: absolute;
+  left: 0px;
+  top: 0px;
+  background-color: gray;
+  z-index: ${MAP_ZINDEX_OVER_MAP};
+  prop2: 2;
+
+  ${(props) => props.theme.components?.M4LDragResizeWindow?.styleOverrides}
+`;
+const draggableWindowClasses = generateUtilityClasses(
+  COMPONENT_CLASS_NAME,
+  [
+    "root",
+    "draggableHandle",
+    "draggableCancel",
+    "dragging"
+  ]
+);
+function setTransform({ top, left, width, height }) {
+  const translate = `translate(${left}px,${top}px)`;
+  return {
+    transform: translate,
+    WebkitTransform: translate,
+    MozTransform: translate,
+    msTransform: translate,
+    OTransform: translate,
+    width: `${width}px`,
+    height: `${height}px`,
+    position: "absolute",
+    prop1: 1
+  };
+}
+const DragResizeWindow = forwardRef(
+  function DragResizeWindowForwardRef(props, ref) {
+    const {
+      style,
+      className,
+      children,
+      defaultPosition = { vertical: { top: 0, height: 100 }, horizontal: { left: 0, width: 100 } },
+      containerElement,
+      containerSize,
+      transformScale = DEFAULT_TRANSFORM_SCALE,
+      bounds = { left: 5, top: 5, right: -5, bottom: -5 },
+      minWindowWidth = 200,
+      minWindowHeight = 100,
+      draggableHandle = `.${draggableWindowClasses.draggableHandle}`,
+      draggableCancel = `.${draggableWindowClasses.draggableCancel}`,
+      draggable = true,
+      onDragStart,
+      onDrag,
+      onDragStop,
+      onMouseDown,
+      resizeable = true,
+      resizeHandles = ["se", "nw"],
+      resizeHandle,
+      onResizeStart,
+      onResize,
+      onResizeStop,
+      ...others
+    } = props;
+    const [currentState, setCurrentState] = useState(() => {
+      let top;
+      let bottom;
+      let height;
+      let left;
+      let right;
+      let width;
+      if ("top" in defaultPosition.vertical) {
+        top = defaultPosition.vertical.top;
+      }
+      if ("bottom" in defaultPosition.vertical) {
+        bottom = defaultPosition.vertical.bottom;
+      }
+      if ("height" in defaultPosition.vertical) {
+        height = defaultPosition.vertical.height;
+      }
+      if ("left" in defaultPosition.horizontal) {
+        left = defaultPosition.horizontal.left;
+      }
+      if ("right" in defaultPosition.horizontal) {
+        right = defaultPosition.horizontal.right;
+      }
+      if ("width" in defaultPosition.horizontal) {
+        width = defaultPosition.horizontal.width;
+      }
+      const containerHeight = containerSize?.containerHeight || 200;
+      const containerWidth = containerSize?.containerWidth || 200;
+      return {
+        top: top || 0,
+        height: height ?? containerHeight - (top || 0) - (bottom || 0),
+        left: left ?? (right ? containerWidth - right - (width || 0) : 0),
+        width: width ?? containerWidth - (left || 0) - (right || 0)
+      };
+    });
+    const stateRef = useRef({
+      bounds,
+      data: void 0,
+      dragging: void 0,
+      containerSize: containerSize ? { ...containerSize } : void 0,
+      left: currentState.left,
+      top: currentState.top,
+      width: currentState.width,
+      height: currentState.height
+    });
+    useImperativeHandle(ref, () => {
+      return {
+        current: wrapperRef.current
+      };
+    });
+    const wrapperRef = useRef(null);
+    const localOnDragStart = useCallback((e, draggableData) => {
+      const { node } = draggableData;
+      const newPosition = { top: 0, left: 0 };
+      const parentRect = containerElement.getBoundingClientRect();
+      const clientRect = node.getBoundingClientRect();
+      const cLeft = clientRect.left / transformScale;
+      const pLeft = parentRect.left / transformScale;
+      const cTop = clientRect.top / transformScale;
+      const pTop = parentRect.top / transformScale;
+      newPosition.left = cLeft - pLeft + containerElement.scrollLeft;
+      newPosition.top = cTop - pTop + containerElement.scrollTop;
+      if (onDragStart) {
+        if (onDragStart(e, draggableData) === false) {
+          return false;
+        }
+      }
+      stateRef.current.dragging = newPosition;
+      setCurrentState((prev) => ({
+        ...prev,
+        ...newPosition,
+        shrinkLeftAt: void 0,
+        shrinkTopAt: void 0,
+        overflowWidthAt: void 0,
+        overflowHeightAt: void 0,
+        dragging: newPosition
+      }));
+    }, []);
+    const localOnDrag = useCallback((e, draggableData) => {
+      const { deltaX, deltaY } = draggableData;
+      if (!stateRef.current.dragging) {
+        return;
+      }
+      if (onDrag) {
+        if (onDrag(e, draggableData) === false) {
+          return false;
+        }
+      }
+      const top = stateRef.current.dragging.top + deltaY;
+      const left = stateRef.current.dragging.left + deltaX;
+      const newPosition = { top, left };
+      stateRef.current.dragging = newPosition;
+      setCurrentState((prev) => ({ ...prev, ...newPosition, dragging: newPosition }));
+    }, []);
+    const localOnDragStop = useCallback((e, draggableData) => {
+      if (!stateRef.current.dragging) {
+        return;
+      }
+      const { left, top } = stateRef.current.dragging;
+      if (onDragStop) {
+        if (onDragStop(e, draggableData) === false) {
+          return false;
+        }
+      }
+      const newPosition = { top, left };
+      stateRef.current.dragging = void 0;
+      setCurrentState((prev) => ({ ...prev, ...newPosition, dragging: void 0 }));
+    }, []);
+    const onResizeHandler = useCallback(
+      (e, data, handlerName) => {
+        const { size, handle } = data;
+        const handler = props[handlerName];
+        containerElement.getBoundingClientRect();
+        if (handler) {
+          handler(e, data);
+        }
+        if (handlerName === "onResizeStart") {
+          stateRef.current.initialPostion = {
+            left: stateRef.current.left,
+            top: stateRef.current.top,
+            width: stateRef.current.width,
+            height: stateRef.current.height
+          };
+        }
+        const resizing = handlerName === "onResizeStop" ? void 0 : { ...size, handle };
+        setCurrentState((prev) => ({
+          ...prev,
+          ...size,
+          ...handlerName === "onResizeStart" ? {
+            shrinkLeftAt: void 0,
+            shrinkTopAt: void 0,
+            overflowWidthAt: void 0,
+            overflowHeightAt: void 0
+          } : {},
+          resizing
+        }));
+        stateRef.current.resizing = resizing;
+      },
+      []
+    );
+    const localOnResizeStart = useCallback(
+      (e, callbackData) => {
+        onResizeHandler(e, callbackData, "onResizeStart");
+      },
+      []
+    );
+    const localOnResize = useCallback((e, callbackData) => {
+      onResizeHandler(e, callbackData, "onResize");
+    }, []);
+    const localOnResizeStop = useCallback((e, callbackData) => {
+      onResizeHandler(e, callbackData, "onResizeStop");
+    }, []);
+    const shringkingParentContainer = useCallback(
+      (newState, cState, containerDimension, divRoot, dimension) => {
+        const lDimension = dimension === "Width" ? "width" : "height";
+        const leftTop = dimension === "Width" ? "left" : "top";
+        const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
+        const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
+        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
+        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
+        const minWindowDimension = dimension === "Width" ? minWindowWidth : minWindowHeight;
+        const minDimension = containerDimension - boundsLefTop + boundsRigthBottom > minWindowDimension ? containerDimension - boundsLefTop + boundsRigthBottom : minWindowDimension;
+        let maxDimensionElement = containerDimension - cState[leftTop] + boundsRigthBottom;
+        if (divRoot[`client${dimension}`] > maxDimensionElement) {
+          const shrinkedPixels = divRoot[`client${dimension}`] - maxDimensionElement;
+          if (shrinkedPixels < cState[leftTop] - boundsLefTop) {
+            newState[leftTop] = newState[leftTop] - shrinkedPixels;
+            newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
+          } else if (shrinkedPixels > cState[leftTop] - boundsLefTop) {
+            newState[leftTop] = boundsLefTop;
+            newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
+            maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
+            if (divRoot[`client${dimension}`] > maxDimensionElement) {
+              newState[lDimension] = maxDimensionElement;
+              newState[overflowDimensionAt] = newState[overflowDimensionAt] || cState[lDimension];
+              if (newState[lDimension] < minDimension) {
+                newState[lDimension] = minDimension;
+              }
+            }
+          }
+        } else {
+          return;
+        }
+      },
+      []
+    );
+    const expandingParentContainer = useCallback(
+      (newState, _currentState, containerDimension, _divRoot, dimension) => {
+        const lDimension = dimension === "Width" ? "width" : "height";
+        const leftTop = dimension === "Width" ? "left" : "top";
+        const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
+        const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
+        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
+        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
+        const maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
+        const valOverflowDimensionAt = newState[overflowDimensionAt];
+        if (valOverflowDimensionAt) {
+          if (valOverflowDimensionAt > maxDimensionElement) {
+            newState[lDimension] = maxDimensionElement;
+          } else {
+            newState[lDimension] = valOverflowDimensionAt;
+            newState[overflowDimensionAt] = void 0;
+          }
+        }
+        const valShrinkLeftTopAt = newState[shrinkLeftTopAt];
+        if (valShrinkLeftTopAt && !newState[overflowDimensionAt]) {
+          const dimensionAvailable = containerDimension - boundsLefTop - newState[lDimension] + boundsRigthBottom;
+          if (valShrinkLeftTopAt <= dimensionAvailable) {
+            newState[leftTop] = valShrinkLeftTopAt;
+            newState[shrinkLeftTopAt] = void 0;
+          } else {
+            newState[leftTop] = dimensionAvailable;
+          }
+        }
+      },
+      []
+    );
+    const draggingOrResizingWindow = useCallback(
+      (newState, _currentState, containerDimension, divRoot, dimension) => {
+        const lDimension = dimension === "Width" ? "width" : "height";
+        const leftTop = dimension === "Width" ? "left" : "top";
+        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
+        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
+        const maxDimensionWithoutBounds = containerDimension - boundsLefTop + boundsRigthBottom;
+        let rightBottomBoundary = containerDimension - newState[lDimension] + boundsRigthBottom;
+        if (newState[lDimension] !== divRoot[`client${dimension}`])
+          ;
+        if (newState.resizing && stateRef.current.initialPostion) {
+          if (!newState.resizing.handle.includes("w")) {
+            if (newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
+              newState[lDimension] = containerDimension - newState[leftTop] + boundsRigthBottom;
+            }
+          } else {
+            if (newState[leftTop] < boundsLefTop) {
+              newState[leftTop] = boundsLefTop;
+            } else {
+              const dif = newState[lDimension] - stateRef.current.initialPostion[lDimension];
+              if (dif > 0) {
+                if (newState[leftTop] - dif >= boundsLefTop) {
+                  newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
+                  newState[leftTop] = newState[leftTop] - dif;
+                  if (newState[leftTop] + newState[lDimension] > maxDimensionWithoutBounds)
+                    ;
+                } else {
+                  newState[leftTop] = boundsLefTop;
+                  newState[lDimension] = stateRef.current.initialPostion[lDimension];
+                }
+              } else if (dif < 0) {
+                newState[leftTop] = newState[leftTop] - dif;
+                newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
+              }
+            }
+          }
+        }
+        if (newState[lDimension] > maxDimensionWithoutBounds) {
+          newState[lDimension] = maxDimensionWithoutBounds;
+        }
+        if (newState[leftTop] < boundsLefTop) {
+          newState[leftTop] = boundsLefTop;
+        }
+        rightBottomBoundary = containerDimension + boundsRigthBottom;
+        if (newState[leftTop] > rightBottomBoundary) {
+          newState[leftTop] = rightBottomBoundary;
+        }
+        if (!newState.resizing && newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
+          const outWidthHeight = newState[leftTop] + newState[lDimension] - (containerDimension + boundsRigthBottom);
+          if (newState[leftTop] - boundsLefTop > outWidthHeight) {
+            newState[leftTop] = newState[leftTop] - outWidthHeight;
+          }
+        }
+        if (newState.resizing && stateRef.current.initialPostion) {
+          stateRef.current.initialPostion[lDimension] = newState[lDimension];
+          stateRef.current.initialPostion[leftTop] = newState[leftTop];
+        }
+      },
+      []
+    );
+    useEffect(() => {
+      if (stateRef.current.containerSize === void 0 && containerSize) {
+        stateRef.current.containerSize = containerSize;
+      }
+      if (!(containerSize && wrapperRef?.current && stateRef.current.containerSize)) {
+        return;
+      }
+      if (currentState?.dragging) {
+        return;
+      }
+      const newState = { ...currentState };
+      const handleDimension = (dimension) => {
+        if (stateRef.current?.containerSize && wrapperRef.current) {
+          const containerSizeKey = `container${dimension}`;
+          const containerSizeValue = containerSize[containerSizeKey];
+          const previousContainerSizeValue = stateRef.current.containerSize[containerSizeKey];
+          if (containerSizeValue > previousContainerSizeValue) {
+            expandingParentContainer(
+              newState,
+              currentState,
+              containerSizeValue,
+              wrapperRef.current,
+              dimension
+            );
+          } else if (containerSizeValue < previousContainerSizeValue) {
+            shringkingParentContainer(
+              newState,
+              currentState,
+              containerSizeValue,
+              wrapperRef.current,
+              dimension
+            );
+          } else {
+            draggingOrResizingWindow(
+              newState,
+              currentState,
+              containerSizeValue,
+              wrapperRef.current,
+              dimension
+            );
+          }
+        }
+      };
+      handleDimension("Width");
+      handleDimension("Height");
+      stateRef.current.containerSize = { ...containerSize };
+      if (newState.left !== currentState.left || newState.top !== currentState.top || newState.width !== currentState.width || newState.height !== currentState.height || newState.shrinkLeftAt !== currentState.shrinkLeftAt || newState.shrinkTopAt !== currentState.shrinkTopAt || newState.overflowWidthAt !== currentState.overflowWidthAt || newState.overflowHeightAt !== currentState.overflowHeightAt) {
+        setCurrentState(newState);
+      }
+      if (!newState.resizing) {
+        stateRef.current.left = newState.left;
+        stateRef.current.top = newState.top;
+        stateRef.current.height = newState.height;
+        stateRef.current.width = newState.width;
+      }
+    }, [
+      currentState,
+      wrapperRef.current,
+      bounds?.left,
+      bounds?.top,
+      bounds?.right,
+      bounds?.bottom,
+      containerSize?.containerWidth,
+      containerSize?.containerHeight
+    ]);
+    const mixinResizable = useCallback(
+      (child, position) => {
+        const minConstraints = [minWindowWidth, minWindowHeight];
+        return /* @__PURE__ */ jsx(
+          Resizable,
+          {
+            draggableOpts: {
+              disabled: !resizeable
+            },
+            className: resizeable ? void 0 : "react-resizable-hide",
+            width: position.width,
+            height: position.height,
+            minConstraints,
+            onResizeStop: localOnResizeStop,
+            onResizeStart: localOnResizeStart,
+            onResize: localOnResize,
+            transformScale,
+            resizeHandles,
+            handle: resizeHandle,
+            children: child
+          }
+        );
+      },
+      [resizeable, transformScale]
+    );
+    const mixinDraggable = useCallback(
+      (child) => {
+        return /* @__PURE__ */ jsx(
+          DraggableCore_1,
+          {
+            onStart: localOnDragStart,
+            onDrag: localOnDrag,
+            onStop: localOnDragStop,
+            handle: draggableHandle,
+            cancel: ".react-resizable-handle" + (draggableCancel ? "," + draggableCancel : ""),
+            scale: transformScale,
+            nodeRef: wrapperRef,
+            onMouseDown,
+            ...others,
+            children: child
+          }
+        );
+      },
+      [wrapperRef, transformScale, draggableHandle, draggableCancel]
+    );
+    const classNameFinal = clsx(draggableWindowClasses.root, className, {
+      "react-draggable": true
+    });
+    const styleFinal = {
+      ...style,
+      ...setTransform(currentState),
+      zIndex: MAP_ZINDEX_OVER_MAP$1,
+      prop2: 1,
+      backgroundColor: "gray"
+    };
+    const memoChildren = useMemo(() => {
+      return children;
+    }, [children]);
+    const wrapperRoot = /* @__PURE__ */ jsx(WrapperWindowRoot, { className: classNameFinal, ref: wrapperRef, style: styleFinal, role: "none", children: memoChildren });
+    const dragResizeWindow = mixinDraggable(mixinResizable(wrapperRoot, currentState));
+    return dragResizeWindow;
+  }
+);
+export {
+  DragResizeWindow as D,
+  draggableWindowClasses as d
+};

package/components/DragResizeWindow/styled.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const WrapperWindowRoot: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/components/DragResizeWindow/types.d.ts

@@ -62,8 +62,7 @@ export declare type DraggableWindowBounds = {
 };
 export declare type ResizeCallback = ((e: React.SyntheticEvent, data: ResizeCallbackData) => any) | undefined;
 export declare type ResizeHandleComponente = React.ReactNode | ((resizeHandle: ResizeHandle, ref: React.RefObject<any>) => React.ReactNode) | undefined;
-export interface PositionParams extends ContainerSize {
-}
+export declare type PositionParams = ContainerSize;
 export declare type ContainerAction = 'equals' | 'shrinking' | 'expanding';
 export declare type DraggableWindowRefProps = {
     current: HTMLDivElement | null;
@@ -124,8 +123,8 @@ export interface DraggableWindowProps extends Partial<Omit<DraggableCoreProps, '
      */
     transformScale?: number | undefined;
     /**
- * "containerElement" contenedor padre
- */
+     * "containerElement" contenedor padre
+     */
     containerElement: HTMLElement;
     /**
      * "containerSize" tamaño del contenedor padre
@@ -182,7 +181,7 @@ export interface DraggableWindowProps extends Partial<Omit<DraggableCoreProps, '
      */
     onResizeStop?: ResizeCallback;
 }
-export interface stateRef extends Pick<DraggableWindowProps, 'bounds'>, CurrentState {
+export interface StateRef extends Pick<DraggableWindowProps, 'bounds'>, CurrentState {
     data?: DraggableData;
     /**
      * containerSize: Tamaño del contenedor padre la ultima vez que se actualizó

package/components/DragResizeWindow/utils.d.ts

@@ -1,2 +1,2 @@
-import { Position } from "./types";
+import { Position } from './types';
 export declare function setTransform({ top, left, width, height }: Position): Record<string, any>;

package/components/DynamicFilter/DynamicFilter.d.ts

@@ -1,8 +1,2 @@
 import type { DynamicFilterProps } from './types';
-/**
- * @description Punto de entrada del componente
- *              El componente inicia su renderización cuando si el Flag FLAG_DICTIONARY_LOADED ha llegado.
- * @param props
- * @returns
- */
-export declare const DynamicFilter: (props: DynamicFilterProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare function DynamicFilter(props: DynamicFilterProps): import("react/jsx-runtime").JSX.Element | null;

package/components/DynamicFilter/constants.d.ts

@@ -1,14 +1,6 @@
-import { BooleanOperator, DateTimeOperator, Field, NumberOperator, Operator, SelectOperator, StringOperator } from './types';
-export declare const COMPONENT_TEST_ID = "M4LDynamicFilter";
-export declare const COMPONENT_PREFIX = "M4LDynamicFilter";
-export declare const COMPONENT_CLASS_NAME = "M4LDynamicFilter";
-export declare const ASSETS_URL = "frontend/components/dynamic_filter/assets/icons";
-export declare const ASSETS: {
-    readonly refresh: "restart.svg";
-    readonly search: "search.svg";
-};
-export declare const ALL_FIELDS: Field;
-export declare const OPERATORS: Array<Operator>;
+import type { BooleanOperator, DateTimeOperator, Field, NumberOperator, SelectOperator, StringOperator } from './types';
+export declare const DYNAMIC_FILTER_KEY_COMPONENT = "M4LDynamicFilter";
+export declare const ALL_FIELD: Field;
 export declare const STRING_OPERATORS: Array<StringOperator>;
 export declare const NUMBER_OPERATORS: Array<NumberOperator>;
 export declare const BOOLEAN_OPERATORS: Array<BooleanOperator>;

package/components/DynamicFilter/dictionary.d.ts

@@ -1,6 +1,5 @@
-export declare const DYNAMICFILTER_DICTIONARY_ID = "dynamic_filter";
+export declare const DYNAMIC_FILTER_DICTIONARY_ID = "dynamic_filter";
 export declare function getDynamicFilterComponentsDictionary(): string[];
-export declare const LABEL_FILTER_BUTTON = "filter_tooltip";
 export declare const DICCTIONARY: {
     readonly input_placeholder: "input_placeholder";
     readonly operand_true: "operand_true";