@muraldevkit/ui-toolkit 4.65.3-dev-IWCo.1 → 4.66.0-dev-avUr.1

package/dist/types/components/menu/constants.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+export type MenuPosition = 'bottom' | 'left' | 'right' | 'top' | 'static' | MenuIgnore;
+export type MenuAlignment = 'start' | 'end' | 'center';
+export type HorizontalAlign = 'left' | 'right' | 'center';
+export type VerticalAlign = 'top' | 'bottom' | 'center';
+export type MenuIgnore = 'ignore';
+export interface CustomMenuPosition {
+    left: number;
+    top: number;
+}
+/**
+ * The type of action that is being performed.
+ *
+ * Used in conjunction with the `ActionState` interface.
+ */
+export type ActionType = 'ArrowUp' | 'ArrowDown' | 'ArrowRight' | 'Enter' | 'Escape' | ' ' | 'click' | null;
+/**
+ * The state of the menu you are interacting with.
+ *
+ * @property {ActionType} actionType - The type of action that is being performed.
+ * @property {boolean} isOpen - Whether the menu is open or not.
+ */
+export interface ActionState {
+    actionType: ActionType;
+    isOpen: boolean;
+}
+/**
+ * Accepted component types for use as a submenu
+ */
+export type SubMenuTypes = 'Menu' | 'Popover';
+/**
+ * Accepted values for aria-haspopup attribute
+ */
+export type AriaHasPopup = React.AriaAttributes['aria-haspopup'];
+/**
+ * Accepted values for menu item role attribute
+ */
+export type MenuItemRole = 'menuitem' | 'menuitemcheckbox' | 'menuitemradio';
+/**
+ * Extension of the React.FunctionComponent type to include a componentType property.
+ *
+ * Allows custom component types to be used to render a submenu.
+ */
+export interface ComponentWithComponentType extends React.FunctionComponent {
+    componentType?: SubMenuTypes;
+}

package/dist/types/components/menu/context/MrlMenuContext.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+type MrlMenuContext = {
+    /**
+     * Close menu is shared in context to allow for closing the menu from a child component
+     *
+     * @returns {void}
+     */
+    closeMenu: (shouldCloseParent?: boolean) => void;
+    /**
+     * Close parent is shared in context to allow for closing the parent menu from a submenu
+     *
+     * @returns {void}
+     */
+    closeParent?: () => void;
+    /**
+     * Reference to the menu trigger button for focus restoration
+     */
+    triggerRef?: React.RefObject<HTMLElement>;
+};
+/**
+ * Adds context for the MrlMenu component
+ */
+export declare const MrlMenuContext: React.Context<MrlMenuContext | undefined>;
+export {};

package/dist/types/components/menu/demo/MenuByConfig.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+/**
+ * Demo of a menu with a trigger for stories and testing
+ *
+ * @returns {Element} The menu with trigger demo
+ */
+export declare const MenuByConfig: () => JSX.Element;

package/dist/types/components/menu/demo/MenuWithPopover.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { MenuPosition, ActionState, MenuAlignment } from '../constants';
+interface MenuWithPopoverProps {
+    position?: MenuPosition;
+    spacing?: 'default' | 'compact';
+    alignment?: MenuAlignment;
+    actionState?: ActionState;
+    onClose?: () => void;
+    triggerAlignment?: 'left' | 'right' | 'center';
+}
+/**
+ * Demo of a menu with a trigger for stories and testing
+ *
+ * @param {MenuWithPopoverProps} props - The props for the menu with trigger
+ * @returns {Element} The menu with trigger demo
+ */
+export declare const MenuWithPopover: ({ alignment, position, spacing, actionState, onClose, triggerAlignment }: MenuWithPopoverProps) => JSX.Element;
+export {};

package/dist/types/components/menu/demo/MenuWithSubmenu.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { MenuPosition, ActionState, MenuAlignment } from '../constants';
+interface MenuWithSubmenuProps {
+    position?: MenuPosition;
+    spacing?: 'default' | 'compact';
+    alignment?: MenuAlignment;
+    actionState?: ActionState;
+    onClose?: () => void;
+    triggerAlignment?: 'left' | 'right' | 'center';
+}
+/**
+ * Demo of a menu with a trigger for stories and testing
+ *
+ * @param {MenuWithSubmenuProps} props - The props for the menu with trigger
+ * @returns {Element} The menu with trigger demo
+ */
+export declare const MenuWithSubmenu: ({ alignment, position, spacing, actionState, onClose, triggerAlignment }: MenuWithSubmenuProps) => JSX.Element;
+export {};

package/dist/types/components/menu/demo/MenuWithTrigger.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { CustomMenuPosition } from '../';
+import { MenuPosition, ActionState, MenuAlignment } from '../constants';
+export interface MenuWithTriggerProps {
+    position?: MenuPosition;
+    spacing?: 'default' | 'compact';
+    alignment?: MenuAlignment;
+    actionState?: ActionState;
+    onClose?: () => void;
+    customPosition?: CustomMenuPosition;
+    triggerAlignment?: 'left' | 'right' | 'center';
+}
+/**
+ * Demo of a menu with a trigger for stories and testing
+ *
+ * @param {MenuWithTriggerProps} props - The props for the menu with trigger
+ * @returns {Element} The menu with trigger demo
+ */
+export declare const MenuWithTrigger: ({ alignment, position, spacing, actionState, customPosition, onClose, triggerAlignment }: MenuWithTriggerProps) => JSX.Element;

package/dist/types/components/menu/hooks/useBrowserEdgeScroll.d.ts

@@ -0,0 +1,22 @@
+import { MenuAlignment, MenuPosition } from '../constants';
+interface ElementScrollStyles {
+    isScrolling: boolean;
+    styles: AdjustedElementStyle;
+}
+export interface AdjustedElementStyle {
+    maxHeight?: string;
+}
+/**
+ * useBrowserEdgeScroll hook
+ *
+ * This hook will calculate if an element's top or bottom edge bleed over the viewport edge
+ * and will provide a max height value for the element to allow it to scroll instead of bleed over
+ *
+ * @param elementRef - reference to the DOM element that is the menu
+ * @param elementPosition - the position of the menu
+ * @param elementAlign - the alignment of the menu
+ * @param disable - disable the hook from running
+ * @returns AdjustedElementStyle - returns the new updated style for scrolling the menu
+ */
+export declare const useBrowserEdgeScroll: (elementRef: React.RefObject<HTMLElement>, elementPosition: MenuPosition | undefined, elementAlign: MenuAlignment, disable?: boolean) => ElementScrollStyles | null;
+export {};

package/dist/types/components/menu/hooks/useMenuScroll.d.ts

@@ -0,0 +1,40 @@
+import { RefObject } from 'react';
+import { MenuPosition } from '../constants';
+interface UseMenuScrollResult {
+    /** The constrained max height for the menu list when scrolling is active */
+    maxHeight: number | undefined;
+    /** Whether the menu content exceeds available space and requires internal scrolling */
+    isScrolling: boolean;
+}
+/**
+ * useMenuScroll hook
+ *
+ * Detects when a menu cannot fit on screen in either its preferred or flipped position,
+ * and constrains its height to enable internal scrolling.
+ *
+ * Behavior by position:
+ * - **top/bottom**: If the menu doesn't fit in the preferred direction AND doesn't fit
+ *   in the opposite direction (flip), it reverts to the original position and constrains
+ *   the height to the space between the trigger edge and the viewport edge.
+ * - **left/right**: Only checks vertical overflow. If the menu is taller than the viewport,
+ *   it constrains the height to the available vertical space.
+ *
+ * Uses `scrollHeight` on the list element to determine the natural (unconstrained) content
+ * height. This value remains stable even when `maxHeight` is applied, preventing feedback
+ * loops with external positioning hooks that use ResizeObserver.
+ *
+ * Uses `useLayoutEffect` for the initial calculation so that `maxHeight` is applied
+ * synchronously before the browser paints. This prevents visible flicker when the menu
+ * opens in a constrained space, because the positioning hook (useTriggerPosition) will
+ * see the already-constrained height on its first measurement via requestAnimationFrame.
+ *
+ * @param triggerRef - Reference to the trigger element that opens the menu
+ * @param listRef - Reference to the ul element inside the menu (the scrollable container)
+ * @param position - The preferred menu position relative to the trigger
+ * @param menuOffset - The gap between the trigger and the menu in pixels
+ * @param isOpen - Whether the menu is currently open
+ * @param disable - Whether to disable the hook entirely
+ * @returns An object with `maxHeight` (inline style value) and `isScrolling` (class toggle)
+ */
+export declare const useMenuScroll: (triggerRef: RefObject<HTMLElement> | undefined, listRef: RefObject<HTMLUListElement>, position: MenuPosition, menuOffset: number, isOpen: boolean, disable: boolean) => UseMenuScrollResult;
+export {};

package/dist/types/components/menu/hooks/useSubMenuElementPosition.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+interface SubMenuPosition {
+    left: string;
+    top: string;
+}
+/**
+ * Calculates the position of the sub menu element
+ *
+ * @param triggerRef - The trigger element ref
+ * @param menuRef - The menu element ref
+ * @param isSubMenu - Is the menu a sub menu
+ * @param isOpen - Is the element visible
+ * @param originalMenuRect - The menu element rect
+ * @param disable - Should the menu be disabled
+ * @returns The sub menu position
+ */
+export declare const useSubMenuElementPosition: (triggerRef: RefObject<HTMLElement> | undefined, menuRef: RefObject<HTMLDivElement>, isSubMenu: boolean, isOpen: boolean, originalMenuRect: DOMRect | null, disable?: boolean) => SubMenuPosition;
+export {};

package/dist/types/components/menu/index.d.ts

@@ -0,0 +1,6 @@
+export * from './MrlMenu';
+export * from './MrlMenuItem';
+export * from './MrlMenuItemLink';
+export * from './MrlMenuGroup';
+export * from './constants';
+export * from './utilities';

package/dist/types/components/menu/utilities/flip-position.d.ts

@@ -0,0 +1,8 @@
+import { MenuPosition } from '../constants';
+/**
+ * Flips the given position to its opposite.
+ *
+ * @param pos - The position to flip. Can be 'left', 'right', 'top', or 'bottom'.
+ * @returns The flipped position. Will be 'right' for 'left', 'left' for 'right', 'bottom' for 'top', and 'top' for 'bottom'.
+ */
+export declare const flipPosition: (pos: MenuPosition) => MenuPosition;

package/dist/types/components/menu/utilities/get-scrollable-parent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the closest scrollable parent of the provided element.
+ *
+ * @param element - The element to start from
+ * @returns The closest scrollable ancestor or the document's scrolling element
+ */
+export declare function getScrollableParent(element: HTMLElement | null): HTMLElement | Window;

package/dist/types/components/menu/utilities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './flip-position';
+export * from './get-scrollable-parent';

package/dist/types/components/modal/MrlModal/MrlModal.d.ts

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { MrlComponentProps } from '../../../utils';
+import { ModalSize, ModalState } from '../constants';
+import './MrlModal.global.scss';
+interface ModalProps extends MrlComponentProps {
+    /**
+     * Aria label for the modal
+     */
+    ariaLabel?: string;
+    /**
+     * Content of the modal
+     */
+    children: React.ReactElement | React.ReactElement[];
+    /**
+     * Modal Wrapper Class
+     */
+    className?: string;
+    /**
+     * !!!!! WARNING: do not use this prop without an explicit requirement from the design team !!!!!
+     *
+     * Enables/disables the ability to close the modal. This prop does the following:
+     * - removes close button
+     * - disables clicking on the overlay to close the modal
+     * - disables the escape key to close the modal
+     */
+    closable?: boolean;
+    /**
+     * Tells the modal whether we are in a loading state.
+     * This is used to disabled FocusTrap until the contents of the modal are loaded
+     */
+    loading?: boolean;
+    /**
+     * Prevents the background from scrolling when the modal is open
+     */
+    preventBackgroundScroll?: boolean;
+    /** The size of the modal container */
+    size?: ModalSize;
+    /** Current state of the modal based on user interactions or permissions */
+    state?: ModalState;
+    /** Additional function to be run when the modal closes */
+    hookClose?: (() => void) | undefined;
+}
+/**
+ * Modal Component.
+ * @param props - Modal props
+ * @returns an instance of the MrlModal
+ */
+export declare const MrlModal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/modal/MrlModal/index.d.ts

@@ -0,0 +1 @@
+export { MrlModal } from './MrlModal';

package/dist/types/components/modal/MrlModalContent/MrlModalContent.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+interface MrlModalContentProps {
+    /**
+     * Children to be rendered within the component.
+     */
+    children: React.ReactElement | React.ReactElement[];
+    /**
+     * Wrapper Class
+     */
+    className?: string;
+}
+/**
+ * Modal Content component for the MrlModal
+ * @param {object} props - The props object
+ * @param {React.ReactElement} props.children - The children to be rendered within the component
+ * @returns {React.ReactElement}} The rendered MrlModalContent component
+ */
+export declare const MrlModalContent: ({ children, className, ...rest }: MrlModalContentProps) => JSX.Element;
+export {};

package/dist/types/components/modal/MrlModalContent/index.d.ts

@@ -0,0 +1 @@
+export { MrlModalContent } from './MrlModalContent';

package/dist/types/components/modal/MrlModalContext/MrlModalContext.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export type MrlModalScrollableContent = {
+    isContentScrollable: boolean;
+    hasScrollTop: boolean;
+    hasScrollBottom: boolean;
+};
+export type MrlModalContextState = {
+    scrollableContent: MrlModalScrollableContent;
+    setScrollableContent: React.Dispatch<React.SetStateAction<MrlModalScrollableContent>>;
+    title: string;
+    setTitle: React.Dispatch<React.SetStateAction<string>>;
+};
+export declare const MrlModalContext: React.Context<MrlModalContextState | undefined>;
+/**
+ * Returns the MrlModalContext state.
+ *
+ * @returns The MrlModalContext state.
+ */
+export declare const useMrlModalContext: () => MrlModalContextState;

package/dist/types/components/modal/MrlModalContext/index.d.ts

@@ -0,0 +1 @@
+export * from './MrlModalContext';

package/dist/types/components/modal/MrlModalFooter/MrlModalFooter.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { MrlComponentProps } from '../../../utils';
+import './MrlModalFooter.global.scss';
+interface MrlModalFooterProps extends MrlComponentProps {
+    /**
+     * Content of the modal footer
+     */
+    children?: React.ReactElement | React.ReactElement[];
+    /**
+     * Wrapper Class
+     */
+    className?: string;
+}
+/**
+ * Modal Footer component for the MrlModal
+ * @param {AttrsObject} attrs - Additional HTML attributes for the `mrl-modal` element
+ * @returns {React.ReactElement} The rendered MrlModalFooter component
+ */
+export declare const MrlModalFooter: ({ attrs, children, className, ...rest }: MrlModalFooterProps) => JSX.Element;
+export {};

package/dist/types/components/modal/MrlModalFooter/index.d.ts

@@ -0,0 +1 @@
+export { MrlModalFooter } from './MrlModalFooter';

package/dist/types/components/modal/MrlModalHeader/MrlModalHeader.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { MrlComponentProps } from '../../../utils';
+export interface MrlModalHeaderProps extends MrlComponentProps {
+    /**
+     * Content of the modal header
+     */
+    children?: React.ReactNode;
+    /**
+     * Wrapper Class
+     */
+    className?: string;
+    /**
+     * Text the h1 element of modal header
+     */
+    text: string;
+}
+/**
+ * Modal Header component for the MrlModal.
+ * @param {MrlModalHeaderProps} props - The props for the MrlModalFooter component
+ * @param {AttrsObject} props.attrs - Additional HTML attributes for the `mrl-modal` element
+ * @returns {React.ReactElement} The rendered MrlModalFooter component
+ */
+export declare const MrlModalHeader: ({ attrs, children, className, text, ...rest }: MrlModalHeaderProps) => JSX.Element;

package/dist/types/components/modal/MrlModalHeader/index.d.ts

@@ -0,0 +1 @@
+export { MrlModalHeader } from './MrlModalHeader';

package/dist/types/components/modal/constants.d.ts

@@ -0,0 +1,18 @@
+import { AttrsObject } from '../../utils';
+export declare const allowedValues: {
+    sizes: readonly ["small", "medium", "large"];
+    states: readonly ["open", "close"];
+};
+export type ModalSize = (typeof allowedValues.sizes)[number];
+export type ModalState = (typeof allowedValues.states)[number];
+export interface ModalDefaults {
+    attrs: AttrsObject;
+    size: ModalSize;
+    state: ModalState;
+}
+/**
+ * Default values for props on the Modal component;
+ * Shared between the component and Storybook
+ */
+export declare const defaults: ModalDefaults;
+export declare const TransitionDuration = 300;

package/dist/types/components/modal/demo/ModalWithTriggerDemo.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import '../MrlModal/stories.scss';
+interface ModalDemoProps {
+    /** Additional function to be run when the modal closes */
+    hookClose?: (() => void) | undefined;
+    closable?: boolean;
+}
+/**
+ * Demo for a modal with a trigger button
+ *
+ * @param {object} props - The props object
+ * @param {Function} props.hookClose - hookClose for modal
+ * @returns {Element} Rendered demo
+ */
+export declare const ModalWithTriggerDemo: ({ closable, hookClose }: ModalDemoProps) => JSX.Element;
+export {};

package/dist/types/components/modal/index.d.ts

@@ -0,0 +1,5 @@
+export * from './MrlModal';
+export * from './MrlModalContent';
+export * from './MrlModalFooter';
+export * from './MrlModalHeader';
+export * from './constants';

package/dist/types/components/navigation-sidebar/MrlSidebarNavGroup/MrlSidebarNavGroup.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { LevelType } from '../../text/constants';
+interface MrlSidebarNavGroupProps extends React.ComponentPropsWithoutRef<'nav'> {
+    /** Additional class to add to the nav element */
+    className?: string;
+    /** A list of navigation items */
+    children: React.ReactNode;
+    /** Set the semantic level of the heading, only applies when headingText is defined */
+    level?: Exclude<LevelType, '1'>;
+    /**
+     *  Sets the heading's text.
+     *  If no visual heading is required add the hiddenHeading prop
+     */
+    headingText: string;
+    /** Prevents rendering the heading and uses aria-label to label the nav element */
+    hiddenHeading?: boolean;
+}
+/**
+ * Sidebar group component
+ *
+ * @param {MrlSidebarNavGroupProps} props - the component props
+ * @returns a sidebar nav group
+ */
+export declare function MrlSidebarNavGroup({ className, children, level, headingText, style, hiddenHeading, ...rest }: MrlSidebarNavGroupProps): JSX.Element;
+export {};

package/dist/types/components/navigation-sidebar/MrlSidebarNavGroup/index.d.ts

@@ -0,0 +1 @@
+export * from './MrlSidebarNavGroup';

package/dist/types/components/navigation-sidebar/MrlSidebarNavItem/MrlSidebarNavItem.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { DSIconType } from '../../';
+interface MrlSidebarNavItemProps {
+    /** Additional class to add to the li element */
+    className?: string;
+    /** A string value used for data-qa attribute. */
+    ['data-qa']?: string;
+    /** Leading icon of the sidebar nav item */
+    icon?: DSIconType;
+    /** Sets the selected state for the sidebar nav item */
+    isSelected?: boolean;
+    /**
+     * Render function used to wrap the sidebar nav item with a link component.
+     * It allows users to wrap the sidebar nav item with different link implementations, react-router's link for example.
+     * @example
+     * <MrlSidebarNavItem renderLink={({linkContent}) => <Link to="/">{linkContent}</Link>}/>
+     * <MrlSidebarNavItem renderLink={({linkContent}) => <a href="/">{linkContent}</a>}/>
+     */
+    renderLink: ({ linkContent }: {
+        linkContent: React.ReactNode;
+    }) => JSX.Element;
+    /** The text of the sidebar item */
+    text?: React.ReactNode;
+}
+/**
+ * Sidebar nav item component
+ * @param {MrlSidebarNavItemProps} props - the component props
+ * @returns a sidebar nav item
+ */
+export declare function MrlSidebarNavItem({ className, ['data-qa']: qa, icon, isSelected, text, renderLink, ...rest }: MrlSidebarNavItemProps): JSX.Element;
+export {};

package/dist/types/components/navigation-sidebar/MrlSidebarNavItem/index.d.ts

@@ -0,0 +1 @@
+export * from './MrlSidebarNavItem';

package/dist/types/components/navigation-sidebar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MrlSidebarNavGroup';
+export * from './MrlSidebarNavItem';

package/dist/types/components/notification/MrlBlockNotification/MrlBlockNotification.d.ts

@@ -0,0 +1,97 @@
+import * as React from 'react';
+import { AttrsObject } from '../../../utils';
+import { NotificationKind, NotificationScope, NotificationState, NotificationLevel } from '../constants';
+import { DSIconType } from '../../svg/MrlSvg/MrlSvg';
+import './MrlBlockNotification.global.scss';
+import { useAutoClose } from '../../../hooks/useAutoClose';
+export interface MrlBlockNotificationProps {
+    /**
+     * Block Notification Wrapper Class
+     */
+    className?: string;
+    /**
+     * QA attribute for close button to allow tests to find the element easier
+     */
+    closeQa?: string;
+    /**
+     * Children
+     *
+     * IMPORTANT! — Make sure to set shouldAutoClose: false if children of this component
+     * contain interactive elements. Autoclosing interactive elements is an accessibility
+     * anti-pattern and should be avoided.
+     */
+    children?: React.ReactNode;
+    /**
+     * Adds CTA button to the notification
+     */
+    cta?: React.ReactElement;
+    /**
+     * The kind of notification to display.
+     *
+     * Examples: warning, error, info, success
+     */
+    kind?: NotificationKind;
+    /**
+     * A custom DS icon.
+     */
+    customIcon?: DSIconType;
+    /**
+     * Sets header text for notification
+     */
+    heading?: string;
+    /**
+     * Adds a close button to notificaiton if true
+     */
+    dismissible?: boolean;
+    /**
+     * Sets the primary content for the notification
+     */
+    message?: React.ReactNode;
+    /**
+     * Sets the scope of the notification
+     */
+    scope?: NotificationScope;
+    /**
+     * Open/Close state of the notification
+     */
+    state?: NotificationState;
+    /**
+     * Open notification callback
+     * @returns {void}
+     */
+    hookOpen?: () => void;
+    /**
+     * Close notification callback
+     * @returns {void}
+     */
+    hookClose?: () => void;
+    /**
+     * Sets the header level
+     * Example output: h1, h2, h3, h4
+     */
+    level?: NotificationLevel;
+    /**
+     * Attributes that are applied to the component during the initial render.
+     *
+     * Example usage: html attributes, custom data attributes (data-qa), aria
+     */
+    attrs?: AttrsObject;
+    /**
+     * When false prevents automated close (e.g. can be used to prevent auto-dismissal of interactive elements, an accessibility anti-pattern) (see useAutoClose)
+     */
+    shouldAutoClose?: Parameters<useAutoClose>[0];
+    /**
+     * Delay in milliseconds before the component closes (see useAutoClose)
+     */
+    autoCloseAfterMs?: Parameters<useAutoClose>[1];
+    /**
+     * Callback to be called when component closes (see useAutoClose)
+     */
+    onAutoClose?: Parameters<useAutoClose>[2];
+}
+/**
+ * Block Notification Component
+ * @param props - Component props
+ * @returns {Element} Block Notification
+ */
+export declare const MrlBlockNotification: (props: MrlBlockNotificationProps) => JSX.Element;

package/dist/types/components/notification/MrlBlockNotification/index.d.ts

@@ -0,0 +1 @@
+export { MrlBlockNotification, type MrlBlockNotificationProps } from './MrlBlockNotification';