@mantine/core 7.0.0-alpha.2 → 7.0.0-alpha.21

package/lib/components/Menu/MenuItem/MenuItem.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, PolymorphicFactory, MantineColor } from '../../../core';
+export type MenuItemStylesNames = 'item' | 'itemLabel' | 'itemSection';
+export interface MenuItemProps extends BoxProps, StylesApiProps<MenuItemFactory> {
+    /** Item label */
+    children?: React.ReactNode;
+    /** Key of `theme.colors` or any valid CSS color */
+    color?: MantineColor;
+    /** Determines whether the menu should be closed when the item is clicked, overrides `closeOnItemClick` prop on the `Menu` component */
+    closeMenuOnClick?: boolean;
+    /** Section displayed on the left side of the label */
+    leftSection?: React.ReactNode;
+    /** Section displayed on the right side of the label */
+    rightSection?: React.ReactNode;
+    /** Disables item */
+    disabled?: boolean;
+}
+export type MenuItemFactory = PolymorphicFactory<{
+    props: MenuItemProps;
+    defaultRef: HTMLButtonElement;
+    defaultComponent: 'button';
+    stylesNames: MenuItemStylesNames;
+    compound: true;
+}>;
+export declare const MenuItem: (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, MenuItemProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(MenuItemProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof MenuItemProps> & {
+    ref?: any; /** Determines whether the menu should be closed when the item is clicked, overrides `closeOnItemClick` prop on the `Menu` component */
+}) | (MenuItemProps & {
+    component: React.ElementType<any>;
+})>, never> & import("../../../core/factory/factory").ThemeExtend<{
+    props: MenuItemProps;
+    defaultRef: HTMLButtonElement;
+    defaultComponent: 'button';
+    stylesNames: MenuItemStylesNames;
+    compound: true;
+}> & import("../../../core/factory/factory").ComponentClasses<{
+    props: MenuItemProps;
+    defaultRef: HTMLButtonElement;
+    defaultComponent: 'button';
+    stylesNames: MenuItemStylesNames;
+    compound: true;
+}> & Record<string, never>;

package/lib/components/Menu/MenuLabel/MenuLabel.d.ts

@@ -0,0 +1,16 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type MenuLabelStylesNames = 'label';
+export interface MenuLabelProps extends BoxProps, StylesApiProps<MenuLabelFactory>, ElementProps<'div'> {
+}
+export type MenuLabelFactory = Factory<{
+    props: MenuLabelProps;
+    ref: HTMLDivElement;
+    stylesNames: MenuLabelStylesNames;
+    compound: true;
+}>;
+export declare const MenuLabel: import("../../../core").MantineComponent<{
+    props: MenuLabelProps;
+    ref: HTMLDivElement;
+    stylesNames: MenuLabelStylesNames;
+    compound: true;
+}>;

package/lib/components/Menu/MenuTarget/MenuTarget.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface MenuTargetProps {
+    /** Target element */
+    children: React.ReactNode;
+    /** Key of the prop that should be used to get element ref */
+    refProp?: string;
+}
+export declare const MenuTarget: React.ForwardRefExoticComponent<MenuTargetProps & React.RefAttributes<HTMLElement>>;

package/lib/components/Menu/index.d.ts

@@ -0,0 +1,12 @@
+export { Menu } from './Menu';
+export { MenuDivider } from './MenuDivider/MenuDivider';
+export { MenuItem } from './MenuItem/MenuItem';
+export { MenuLabel } from './MenuLabel/MenuLabel';
+export { MenuDropdown } from './MenuDropdown/MenuDropdown';
+export { MenuTarget } from './MenuTarget/MenuTarget';
+export type { MenuFactory, MenuProps, MenuStylesNames } from './Menu';
+export type { MenuDividerProps } from './MenuDivider/MenuDivider';
+export type { MenuItemProps } from './MenuItem/MenuItem';
+export type { MenuLabelProps } from './MenuLabel/MenuLabel';
+export type { MenuDropdownProps } from './MenuDropdown/MenuDropdown';
+export type { MenuTargetProps } from './MenuTarget/MenuTarget';

package/lib/components/Modal/Modal.context.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import type { ModalRootFactory } from './ModalRoot';
+export type ScrollAreaComponent = React.FC<any>;
+interface ModalContext {
+    yOffset: string | number | undefined;
+    scrollAreaComponent: ScrollAreaComponent | undefined;
+    getStyles: GetStylesApi<ModalRootFactory>;
+}
+export declare const ModalProvider: ({ children, value }: {
+    value: ModalContext;
+    children: import("react").ReactNode;
+}) => import("react/jsx-runtime").JSX.Element, useModalContext: () => ModalContext;
+export {};

package/lib/components/Modal/Modal.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+import { Factory } from '../../core';
+import { ModalBaseOverlayProps, ModalBaseCloseButtonProps } from '../ModalBase';
+import { ModalRoot, ModalRootProps, ModalRootCssVariables, ModalRootStylesNames } from './ModalRoot';
+import { ModalBody } from './ModalBody';
+import { ModalCloseButton } from './ModalCloseButton';
+import { ModalOverlay } from './ModalOverlay';
+import { ModalContent } from './ModalContent';
+import { ModalTitle } from './ModalTitle';
+import { ModalHeader } from './ModalHeader';
+export type ModalStylesNames = ModalRootStylesNames;
+export type ModalCssVariables = ModalRootCssVariables;
+export interface ModalProps extends ModalRootProps {
+    __staticSelector?: string;
+    /** Modal title */
+    title?: React.ReactNode;
+    /** Determines whether the overlay should be rendered, `true` by default */
+    withOverlay?: boolean;
+    /** Props passed down to the `Overlay` component, use to configure opacity, `background-color`, styles and other properties */
+    overlayProps?: ModalBaseOverlayProps;
+    /** Modal content */
+    children?: React.ReactNode;
+    /** Determines whether the close button should be rendered, `true` by default */
+    withCloseButton?: boolean;
+    /** Props passed down to the close button */
+    closeButtonProps?: ModalBaseCloseButtonProps;
+}
+export type ModalFactory = Factory<{
+    props: ModalProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalStylesNames;
+    vars: ModalCssVariables;
+    staticComponents: {
+        Root: typeof ModalRoot;
+        Overlay: typeof ModalOverlay;
+        Content: typeof ModalContent;
+        Body: typeof ModalBody;
+        Header: typeof ModalHeader;
+        Title: typeof ModalTitle;
+        CloseButton: typeof ModalCloseButton;
+    };
+}>;
+export declare const Modal: import("../../core").MantineComponent<{
+    props: ModalProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalStylesNames;
+    vars: ModalCssVariables;
+    staticComponents: {
+        Root: typeof ModalRoot;
+        Overlay: typeof ModalOverlay;
+        Content: typeof ModalContent;
+        Body: typeof ModalBody;
+        Header: typeof ModalHeader;
+        Title: typeof ModalTitle;
+        CloseButton: typeof ModalCloseButton;
+    };
+}>;

package/lib/components/Modal/ModalBody.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseBodyProps } from '../ModalBase';
+export type ModalBodyStylesNames = 'body';
+export interface ModalBodyProps extends ModalBaseBodyProps, StylesApiProps<ModalBodyFactory> {
+}
+export type ModalBodyFactory = Factory<{
+    props: ModalBodyProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalBodyStylesNames;
+    compound: true;
+}>;
+export declare const ModalBody: import("../../core").MantineComponent<{
+    props: ModalBodyProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalBodyStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/ModalCloseButton.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseCloseButtonProps } from '../ModalBase';
+export type ModalCloseButtonStylesNames = 'close';
+export interface ModalCloseButtonProps extends ModalBaseCloseButtonProps, StylesApiProps<ModalCloseButtonFactory> {
+}
+export type ModalCloseButtonFactory = Factory<{
+    props: ModalCloseButtonProps;
+    ref: HTMLButtonElement;
+    stylesNames: ModalCloseButtonStylesNames;
+    compound: true;
+}>;
+export declare const ModalCloseButton: import("../../core").MantineComponent<{
+    props: ModalCloseButtonProps;
+    ref: HTMLButtonElement;
+    stylesNames: ModalCloseButtonStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/ModalContent.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseContentProps } from '../ModalBase';
+export type ModalContentStylesNames = 'content' | 'inner';
+export interface ModalContentProps extends ModalBaseContentProps, StylesApiProps<ModalContentFactory> {
+}
+export type ModalContentFactory = Factory<{
+    props: ModalContentProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalContentStylesNames;
+    compound: true;
+}>;
+export declare const ModalContent: import("../../core").MantineComponent<{
+    props: ModalContentProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalContentStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/ModalHeader.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseHeaderProps } from '../ModalBase';
+export type ModalHeaderStylesNames = 'header';
+export interface ModalHeaderProps extends ModalBaseHeaderProps, StylesApiProps<ModalHeaderFactory> {
+}
+export type ModalHeaderFactory = Factory<{
+    props: ModalHeaderProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalHeaderStylesNames;
+    compound: true;
+}>;
+export declare const ModalHeader: import("../../core").MantineComponent<{
+    props: ModalHeaderProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalHeaderStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/ModalOverlay.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseOverlayProps } from '../ModalBase';
+export type ModalOverlayStylesNames = 'overlay';
+export interface ModalOverlayProps extends ModalBaseOverlayProps, StylesApiProps<ModalOverlayFactory> {
+}
+export type ModalOverlayFactory = Factory<{
+    props: ModalOverlayProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalOverlayStylesNames;
+    compound: true;
+}>;
+export declare const ModalOverlay: import("../../core").MantineComponent<{
+    props: ModalOverlayProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalOverlayStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/ModalRoot.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { StylesApiProps, Factory, MantineRadius } from '../../core';
+import { ModalBaseProps, ModalBaseStylesNames } from '../ModalBase';
+import { ScrollAreaComponent } from './Modal.context';
+export type ModalRootStylesNames = ModalBaseStylesNames;
+export type ModalRootCssVariables = {
+    root: '--modal-radius' | '--modal-size' | '--modal-y-offset' | '--modal-x-offset';
+};
+export interface ModalRootProps extends StylesApiProps<ModalRootFactory>, ModalBaseProps {
+    __staticSelector?: string;
+    /** Top/bottom modal offset, `5dvh` by default */
+    yOffset?: React.CSSProperties['marginTop'];
+    /** Left/right modal offset, `5vw` by default */
+    xOffset?: React.CSSProperties['marginLeft'];
+    /** Scroll area component, native `div` element by default */
+    scrollAreaComponent?: ScrollAreaComponent;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, `theme.defaultRadius` by default */
+    radius?: MantineRadius | (string & {}) | number;
+    /** Determines whether the modal should be centered vertically, `false` by default */
+    centered?: boolean;
+    /** Determines whether the modal should take the entire screen, `false` by default */
+    fullScreen?: boolean;
+}
+export type ModalRootFactory = Factory<{
+    props: ModalRootProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalRootStylesNames;
+    vars: ModalRootCssVariables;
+    compound: true;
+}>;
+export declare const ModalRoot: import("../../core").MantineComponent<{
+    props: ModalRootProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalRootStylesNames;
+    vars: ModalRootCssVariables;
+    compound: true;
+}>;

package/lib/components/Modal/ModalTitle.d.ts

@@ -0,0 +1,17 @@
+import { StylesApiProps, Factory } from '../../core';
+import { ModalBaseTitleProps } from '../ModalBase';
+export type ModalTitleStylesNames = 'title';
+export interface ModalTitleProps extends ModalBaseTitleProps, StylesApiProps<ModalTitleFactory> {
+}
+export type ModalTitleFactory = Factory<{
+    props: ModalTitleProps;
+    ref: HTMLHeadingElement;
+    stylesNames: ModalTitleStylesNames;
+    compound: true;
+}>;
+export declare const ModalTitle: import("../../core").MantineComponent<{
+    props: ModalTitleProps;
+    ref: HTMLHeadingElement;
+    stylesNames: ModalTitleStylesNames;
+    compound: true;
+}>;

package/lib/components/Modal/index.d.ts

@@ -0,0 +1,16 @@
+export { Modal } from './Modal';
+export { ModalRoot } from './ModalRoot';
+export { ModalBody } from './ModalBody';
+export { ModalCloseButton } from './ModalCloseButton';
+export { ModalContent } from './ModalContent';
+export { ModalHeader } from './ModalHeader';
+export { ModalOverlay } from './ModalOverlay';
+export { ModalTitle } from './ModalTitle';
+export type { ModalCssVariables, ModalFactory, ModalProps, ModalStylesNames } from './Modal';
+export type { ModalRootProps } from './ModalRoot';
+export type { ModalBodyProps } from './ModalBody';
+export type { ModalCloseButtonProps } from './ModalCloseButton';
+export type { ModalContentProps } from './ModalContent';
+export type { ModalHeaderProps } from './ModalHeader';
+export type { ModalOverlayProps } from './ModalOverlay';
+export type { ModalTitleProps } from './ModalTitle';

package/lib/components/ModalBase/ModalBase.context.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { TransitionOverride } from '../Transition';
+interface ModalBaseContextValue {
+    titleMounted: boolean;
+    bodyMounted: boolean;
+    setTitleMounted(value: boolean): void;
+    setBodyMounted(value: boolean): void;
+    getTitleId(): string;
+    getBodyId(): string;
+    transitionProps: Partial<TransitionOverride> | undefined;
+    zIndex: string | number | undefined;
+    opened: boolean;
+    onClose(): void;
+    closeOnEscape: boolean | undefined;
+    trapFocus: boolean | undefined;
+    closeOnClickOutside: boolean | undefined;
+}
+export declare const ModalBaseProvider: ({ children, value }: {
+    value: ModalBaseContextValue;
+    children: import("react").ReactNode;
+}) => import("react/jsx-runtime").JSX.Element, useModalBaseContext: () => ModalBaseContextValue;
+export {};

package/lib/components/ModalBase/ModalBase.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { BoxProps, ElementProps, MantineShadow, MantineSize, MantineSpacing } from '../../core';
+import { PortalProps } from '../Portal';
+import { TransitionOverride } from '../Transition';
+export interface ModalBaseProps extends BoxProps, ElementProps<'div', 'title'> {
+    /** If set modal/drawer will not be unmounted from the DOM when it is hidden, `display: none` styles will be added instead, `false` by default */
+    keepMounted?: boolean;
+    /** Determines whether modal/drawer is opened */
+    opened: boolean;
+    /** Called when modal/drawer is closed */
+    onClose(): void;
+    /** Id used to connect modal/drawer with body and title */
+    id?: string;
+    /** Determines whether scroll should be locked when `opened={true}`, `true` by default */
+    lockScroll?: boolean;
+    /** Determines whether focus should be trapped, `true` by default */
+    trapFocus?: boolean;
+    /** Determines whether the component should be rendered inside `Portal`, `true` by default */
+    withinPortal?: boolean;
+    /** Props passed down to the Portal component when `withinPortal` is set */
+    portalProps?: Omit<PortalProps, 'children'>;
+    /** Modal/drawer content */
+    children?: React.ReactNode;
+    /** Determines whether the modal/drawer should be closed when user clicks on the overlay, `true` by default */
+    closeOnClickOutside?: boolean;
+    /** Props added to the `Transition` component that used to animate overlay and body, use to configure duration and animation type, `{ duration: 200, transition: 'pop' }` by default */
+    transitionProps?: TransitionOverride;
+    /** Determines whether `onClose` should be called when user presses the escape key, `true` by default */
+    closeOnEscape?: boolean;
+    /** Determines whether focus should be returned to the last active element when `onClose` is called, `true` by default */
+    returnFocus?: boolean;
+    /** `z-index` CSS property of the root element, `200` by default */
+    zIndex?: string | number;
+    /** Key of `theme.shadows` or any valid CSS box-shadow value, 'xl' by default */
+    shadow?: MantineShadow | (string & {});
+    /** Key of `theme.spacing` or any valid CSS value to set content, header and footer padding, `'md'` by default */
+    padding?: MantineSpacing | (string & {}) | number;
+    /** Controls width of the content area, `'md'` by default */
+    size?: MantineSize | (string & {}) | number;
+}
+export declare const ModalBase: React.ForwardRefExoticComponent<ModalBaseProps & React.RefAttributes<HTMLDivElement>>;

package/lib/components/ModalBase/ModalBaseBody.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { BoxProps, ElementProps } from '../../core';
+export interface ModalBaseBodyProps extends BoxProps, ElementProps<'div'> {
+}
+export declare const ModalBaseBody: React.ForwardRefExoticComponent<ModalBaseBodyProps & React.RefAttributes<HTMLDivElement>>;

package/lib/components/ModalBase/ModalBaseCloseButton.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { BoxProps, ElementProps } from '../../core';
+export interface ModalBaseCloseButtonProps extends BoxProps, ElementProps<'button'> {
+}
+export declare const ModalBaseCloseButton: React.ForwardRefExoticComponent<ModalBaseCloseButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/lib/components/ModalBase/ModalBaseContent.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { BoxProps, ElementProps, MantineRadius, MantineShadow } from '../../core';
+import { TransitionOverride } from '../Transition';
+export interface ModalBaseContentProps extends BoxProps, ElementProps<'div'> {
+    /** Props passed down to the `Transition` component */
+    transitionProps?: TransitionOverride;
+    /** Key of `theme.shadows` or any valid CSS value to set `box-shadow`, `none` by default */
+    shadow?: MantineShadow | (string & {});
+    /** Key of `theme.radius` or any valid CSS value to set border-radius, numbers are converted to rem, `theme.defaultRadius` by default */
+    radius?: MantineRadius | number | (string & {});
+}
+interface _ModalBaseContentProps extends ModalBaseContentProps {
+    innerProps: React.ComponentPropsWithoutRef<'div'>;
+}
+export declare const ModalBaseContent: React.ForwardRefExoticComponent<_ModalBaseContentProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/lib/components/ModalBase/ModalBaseHeader.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { BoxProps, ElementProps } from '../../core';
+export interface ModalBaseHeaderProps extends BoxProps, ElementProps<'div'> {
+}
+export declare const ModalBaseHeader: React.ForwardRefExoticComponent<ModalBaseHeaderProps & React.RefAttributes<HTMLDivElement>>;

package/lib/components/ModalBase/ModalBaseOverlay.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ElementProps } from '../../core';
+import { OverlayProps } from '../Overlay';
+import { TransitionOverride } from '../Transition';
+export interface ModalBaseOverlayProps extends Omit<OverlayProps, 'styles' | 'classNames' | 'variant' | 'vars'>, ElementProps<'div', 'color'> {
+    /** Props passed down to the `Transition` component */
+    transitionProps?: TransitionOverride;
+}
+export declare const ModalBaseOverlay: React.ForwardRefExoticComponent<ModalBaseOverlayProps & React.RefAttributes<HTMLDivElement>>;

package/lib/components/ModalBase/ModalBaseTitle.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { BoxProps, ElementProps } from '../../core';
+export interface ModalBaseTitleProps extends BoxProps, ElementProps<'h2'> {
+}
+export declare const ModalBaseTitle: React.ForwardRefExoticComponent<ModalBaseTitleProps & React.RefAttributes<HTMLHeadingElement>>;

package/lib/components/ModalBase/NativeScrollArea.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface NativeScrollAreaProps {
+    children: React.ReactNode;
+}
+export declare function NativeScrollArea({ children }: NativeScrollAreaProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/components/ModalBase/index.d.ts

@@ -0,0 +1,16 @@
+export { ModalBase } from './ModalBase';
+export { ModalBaseBody } from './ModalBaseBody';
+export { ModalBaseCloseButton } from './ModalBaseCloseButton';
+export { ModalBaseContent } from './ModalBaseContent';
+export { ModalBaseHeader } from './ModalBaseHeader';
+export { ModalBaseOverlay } from './ModalBaseOverlay';
+export { ModalBaseTitle } from './ModalBaseTitle';
+export { NativeScrollArea } from './NativeScrollArea';
+export type { ModalBaseProps } from './ModalBase';
+export type { ModalBaseBodyProps } from './ModalBaseBody';
+export type { ModalBaseCloseButtonProps } from './ModalBaseCloseButton';
+export type { ModalBaseContentProps } from './ModalBaseContent';
+export type { ModalBaseHeaderProps } from './ModalBaseHeader';
+export type { ModalBaseOverlayProps } from './ModalBaseOverlay';
+export type { ModalBaseTitleProps } from './ModalBaseTitle';
+export type ModalBaseStylesNames = 'body' | 'header' | 'title' | 'overlay' | 'root' | 'content' | 'close' | 'inner';

package/lib/components/ModalBase/use-lock-scroll.d.ts

@@ -0,0 +1,6 @@
+interface UseScrollLock {
+    opened: boolean;
+    transitionDuration: number;
+}
+export declare function useLockScroll({ opened, transitionDuration }: UseScrollLock): boolean;
+export {};

package/lib/components/ModalBase/use-modal-body-id.d.ts

@@ -0,0 +1 @@
+export declare function useModalBodyId(): string;

package/lib/components/ModalBase/use-modal-content.d.ts

@@ -0,0 +1,12 @@
+export declare function useModalContentProps(): {
+    focusTrapActive: boolean | undefined;
+    contentProps: {
+        component: "section";
+        onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+        role: "dialog";
+        tabIndex: number;
+        'aria-modal': boolean;
+        'aria-describedby': string | undefined;
+        'aria-labelledby': string | undefined;
+    };
+};

package/lib/components/ModalBase/use-modal-title-id.d.ts

@@ -0,0 +1 @@
+export declare function useModalTitle(): string;

package/lib/components/ModalBase/use-modal-transition.d.ts

@@ -0,0 +1,2 @@
+import { TransitionOverride } from '../Transition';
+export declare function useModalTransition(transitionOverride: TransitionOverride | undefined): TransitionOverride;

package/lib/components/ModalBase/use-modal.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { TransitionOverride } from '../Transition';
+interface UseModalInput {
+    opened: boolean;
+    onClose(): void;
+    id: string | undefined;
+    transitionProps: TransitionOverride | undefined;
+    trapFocus: boolean | undefined;
+    closeOnEscape: boolean | undefined;
+    returnFocus: boolean | undefined;
+}
+export declare function useModal({ id, transitionProps, opened, trapFocus, closeOnEscape, onClose, returnFocus, }: UseModalInput): {
+    _id: string;
+    titleMounted: boolean;
+    bodyMounted: boolean;
+    shouldLockScroll: boolean;
+    setTitleMounted: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setBodyMounted: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};
+export {};

package/lib/components/MultiSelect/MultiSelect.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../core';
+import { ComboboxLikeProps, ComboboxLikeStylesNames } from '../Combobox';
+import { __BaseInputProps, __InputStylesNames } from '../Input';
+export type MultiSelectStylesNames = __InputStylesNames | ComboboxLikeStylesNames | 'pill' | 'pillsList' | 'inputField';
+export interface MultiSelectProps extends BoxProps, __BaseInputProps, ComboboxLikeProps, StylesApiProps<MultiSelectFactory>, ElementProps<'input', 'size' | 'value' | 'defaultValue' | 'onChange'> {
+    /** Controlled component value */
+    value?: string[];
+    /** Default value for uncontrolled component */
+    defaultValue?: string[];
+    /** Called whe value changes */
+    onChange?(value: string[]): void;
+    /** Controlled search value */
+    searchValue?: string;
+    /** Default search value */
+    defaultSearchValue?: string;
+    /** Called when search changes */
+    onSearchChange?(value: string): void;
+    /** Maximum number of values, `Infinity` by default */
+    maxValues?: number;
+    /** Determines whether the select should be searchable, `false` by default */
+    searchable?: boolean;
+    /** Message displayed when no option matched current search query, only applicable when `searchable` prop is set */
+    nothingFoundMessage?: React.ReactNode;
+    /** Determines whether check icon should be displayed near the selected option label, `true` by default */
+    withCheckIcon?: boolean;
+    /** Position of the check icon relative to the option label, `'left'` by default */
+    checkIconPosition?: 'left' | 'right';
+    /** Determines whether picked options should be removed from the options list, `false` by default */
+    hidePickedOptions?: boolean;
+}
+export type MultiSelectFactory = Factory<{
+    props: MultiSelectProps;
+    ref: HTMLInputElement;
+    stylesNames: MultiSelectStylesNames;
+}>;
+export declare const MultiSelect: import("../../core").MantineComponent<{
+    props: MultiSelectProps;
+    ref: HTMLInputElement;
+    stylesNames: MultiSelectStylesNames;
+}>;

package/lib/components/MultiSelect/filter-picked-values.d.ts

@@ -0,0 +1,7 @@
+import { ComboboxParsedItem } from '../Combobox';
+interface FilterPickedTagsInput {
+    data: ComboboxParsedItem[];
+    value: string[];
+}
+export declare function filterPickedValues({ data, value }: FilterPickedTagsInput): ComboboxParsedItem[];
+export {};

package/lib/components/MultiSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { MultiSelect } from './MultiSelect';
+export type { MultiSelectFactory, MultiSelectProps, MultiSelectStylesNames } from './MultiSelect';

package/lib/components/NativeSelect/NativeSelectOption.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="react" />
 import { ComboboxParsedItem } from '../Combobox';
 export interface NativeSelectOptionProps {
     data: ComboboxParsedItem;
 }
-export declare function NativeSelectOption({ data }: NativeSelectOptionProps): JSX.Element;
+export declare function NativeSelectOption({ data }: NativeSelectOptionProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace NativeSelectOption {
     var displayName: string;
 }

package/lib/components/Notification/Notification.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineRadius, MantineColor } from '../../core';
+export type NotificationStylesNames = 'root' | 'icon' | 'loader' | 'body' | 'title' | 'description' | 'closeButton';
+export type NotificationCssVariables = {
+    root: '--notification-radius' | '--notification-color';
+};
+export interface NotificationProps extends BoxProps, StylesApiProps<NotificationFactory>, ElementProps<'div', 'title'> {
+    variant?: string;
+    /** Called when close button is clicked */
+    onClose?(): void;
+    /** Controls notification line or icon color, key of `theme.colors` or any valid CSS color, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, `theme.defaultRadius` by default */
+    radius?: MantineRadius | (string & {}) | number;
+    /** Notification icon, replaces color line */
+    icon?: React.ReactNode;
+    /** Notification title, displayed before body */
+    title?: React.ReactNode;
+    /** Notification body, place main text here */
+    children?: React.ReactNode;
+    /** Replaces colored line or icon with Loader component */
+    loading?: boolean;
+    /** Determines whether notification should have a border, `false` by default */
+    withBorder?: boolean;
+    /** Determines whether close button should be visible, `true` by default */
+    withCloseButton?: boolean;
+    /** Props passed down to the close button */
+    closeButtonProps?: Record<string, any>;
+}
+export type NotificationFactory = Factory<{
+    props: NotificationProps;
+    ref: HTMLDivElement;
+    stylesNames: NotificationStylesNames;
+    vars: NotificationCssVariables;
+}>;
+export declare const Notification: import("../../core").MantineComponent<{
+    props: NotificationProps;
+    ref: HTMLDivElement;
+    stylesNames: NotificationStylesNames;
+    vars: NotificationCssVariables;
+}>;

package/lib/components/Notification/index.d.ts

@@ -0,0 +1,2 @@
+export { Notification } from './Notification';
+export type { NotificationCssVariables, NotificationFactory, NotificationProps, NotificationStylesNames, } from './Notification';