@mantine/core 7.0.0-alpha.12 → 7.0.0-alpha.13

package/lib/components/Fieldset/Fieldset.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineRadius } from '../../core';
+export type FieldsetStylesNames = 'root' | 'legend';
+export type FieldsetVariant = 'default' | 'filled' | 'unstyled';
+export type FieldsetCSSVariables = {
+    root: '--fieldset-radius';
+};
+export interface FieldsetProps extends BoxProps, StylesApiProps<FieldsetFactory>, ElementProps<'fieldset'> {
+    /** Fieldset legend */
+    legend?: React.ReactNode;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, `theme.defaultRadius` by default */
+    radius?: MantineRadius | (string & {}) | number;
+}
+export type FieldsetFactory = Factory<{
+    props: FieldsetProps;
+    ref: HTMLFieldSetElement;
+    stylesNames: FieldsetStylesNames;
+    vars: FieldsetCSSVariables;
+    variant: FieldsetVariant;
+}>;
+export declare const Fieldset: import("../../core").MantineComponent<{
+    props: FieldsetProps;
+    ref: HTMLFieldSetElement;
+    stylesNames: FieldsetStylesNames;
+    vars: FieldsetCSSVariables;
+    variant: FieldsetVariant;
+}>;

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

@@ -0,0 +1,2 @@
+export { Fieldset } from './Fieldset';
+export type { FieldsetFactory, FieldsetProps, FieldsetStylesNames, FieldsetVariant, } from './Fieldset';

package/lib/components/Highlight/Highlight.d.ts

@@ -30,4 +30,10 @@ export declare const Highlight: (<C = "div">(props: import("../../core/factory/c
     defaultComponent: 'div';
     stylesNames: TextStylesNames;
     variant: TextVariant;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: HighlightProps;
+    defaultRef: HTMLDivElement;
+    defaultComponent: 'div';
+    stylesNames: TextStylesNames;
+    variant: TextVariant;
 }> & Record<string, never>;

package/lib/components/InlineInput/InlineInput.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { BoxProps, StylesApiProps, ElementProps, MantineSize, Factory } from '../../core';
+export declare const InlineInputClasses: any;
 export type InlineInputStylesNames = 'root' | 'body' | 'labelWrapper' | 'label' | 'description' | 'error';
 export interface InlineInputProps extends BoxProps, StylesApiProps<InlineInputFactory>, ElementProps<'div'> {
     __staticSelector: string;

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

@@ -1,2 +1,2 @@
-export { InlineInput } from './InlineInput';
+export { InlineInput, InlineInputClasses } from './InlineInput';
 export type { InlineInputStylesNames } from './InlineInput';

package/lib/components/Input/Input.d.ts

@@ -93,6 +93,21 @@ export declare const Input: (<C = "input">(props: import("../../core/factory/cre
         Placeholder: typeof InputPlaceholder;
         Wrapper: typeof InputWrapper;
     };
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: InputProps;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: InputStylesNames;
+    variant: InputVariant;
+    vars: InputCssVariables;
+    ctx: InputStylesCtx;
+    staticComponents: {
+        Label: typeof InputLabel;
+        Error: typeof InputError;
+        Description: typeof InputDescription;
+        Placeholder: typeof InputPlaceholder;
+        Wrapper: typeof InputWrapper;
+    };
 }> & {
     Label: typeof InputLabel;
     Error: typeof InputError;

package/lib/components/InputBase/InputBase.d.ts

@@ -25,4 +25,10 @@ export declare const InputBase: (<C = "input">(props: import("../../core/factory
     defaultComponent: 'input';
     stylesNames: __InputStylesNames;
     variant: InputVariant;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: InputBaseProps;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: __InputStylesNames;
+    variant: InputVariant;
 }> & Record<string, never>;

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;
+}) => JSX.Element, useModalContext: () => ModalContext;
+export {};

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

@@ -0,0 +1,59 @@
+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 ModalVariant = string;
+export type ModalCssVariables = ModalRootCssVariables;
+export interface ModalProps extends ModalRootProps {
+    /** Modal title */
+    title?: React.ReactNode;
+    /** Determines whether 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 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;
+    variant: ModalVariant;
+    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;
+    variant: ModalVariant;
+    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,39 @@
+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 ModalRootVariant = string;
+export type ModalRootCssVariables = {
+    root: '--modal-radius' | '--modal-size' | '--modal-y-offset' | '--modal-x-offset';
+};
+export interface ModalRootProps extends StylesApiProps<ModalRootFactory>, ModalBaseProps {
+    /** Top/bottom modal offset, `5vh` 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;
+    variant: ModalRootVariant;
+    compound: true;
+}>;
+export declare const ModalRoot: import("../../core").MantineComponent<{
+    props: ModalRootProps;
+    ref: HTMLDivElement;
+    stylesNames: ModalRootStylesNames;
+    vars: ModalRootCssVariables;
+    variant: ModalRootVariant;
+    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, ModalVariant, } 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: React.CSSProperties['zIndex'];
+    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;
+}) => 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?: React.CSSProperties['zIndex'];
+    /** 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,12 @@
+import React from 'react';
+import { BoxProps, ElementProps } from '../../core';
+import { TransitionOverride } from '../Transition';
+export interface ModalBaseContentProps extends BoxProps, ElementProps<'div'> {
+    /** Props passed down to the `Transition` component */
+    transitionProps?: TransitionOverride;
+}
+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): 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,19 @@
+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/Notification/Notification.d.ts

@@ -0,0 +1,44 @@
+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 NotificationVariant = string;
+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;
+    variant: NotificationVariant;
+}>;
+export declare const Notification: import("../../core").MantineComponent<{
+    props: NotificationProps;
+    ref: HTMLDivElement;
+    stylesNames: NotificationStylesNames;
+    vars: NotificationCssVariables;
+    variant: NotificationVariant;
+}>;

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

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

package/lib/components/Overlay/Overlay.d.ts

@@ -46,4 +46,11 @@ export declare const Overlay: (<C = "div">(props: import("../../core/factory/cre
     stylesNames: OverlayStylesNames;
     vars: OverlayCssVariables;
     variant: OverlayVariant;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: OverlayProps;
+    defaultRef: HTMLDivElement;
+    defaultComponent: 'div';
+    stylesNames: OverlayStylesNames;
+    vars: OverlayCssVariables;
+    variant: OverlayVariant;
 }> & Record<string, never>;

package/lib/components/Paper/Paper.d.ts

@@ -32,4 +32,10 @@ export declare const Paper: (<C = "div">(props: import("../../core/factory/creat
     defaultRef: HTMLDivElement;
     stylesNames: PaperStylesNames;
     vars: PaperCssVariables;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: PaperProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLDivElement;
+    stylesNames: PaperStylesNames;
+    vars: PaperCssVariables;
 }> & Record<string, never>;

package/lib/components/Text/Text.d.ts

@@ -45,5 +45,12 @@ export declare const Text: (<C = "div">(props: import("../../core/factory/create
     stylesNames: TextStylesNames;
     vars: TextCssVariables;
     variant: TextVariant;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: TextProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLParagraphElement;
+    stylesNames: TextStylesNames;
+    vars: TextCssVariables;
+    variant: TextVariant;
 }> & Record<string, never>;
 export {};

package/lib/components/UnstyledButton/UnstyledButton.d.ts

@@ -21,4 +21,9 @@ export declare const UnstyledButton: (<C = "button">(props: import("../../core/f
     stylesNames: UnstyledButtonStylesNames;
     defaultComponent: 'button';
     defaultRef: HTMLButtonElement;
+}> & import("../../core/factory/factory").ComponentClasses<{
+    props: UnstyledButtonProps;
+    stylesNames: UnstyledButtonStylesNames;
+    defaultComponent: 'button';
+    defaultRef: HTMLButtonElement;
 }> & Record<string, never>;

package/lib/components/VisuallyHidden/VisuallyHidden.d.ts

@@ -3,5 +3,6 @@ export interface VisuallyHiddenProps extends React.ComponentPropsWithoutRef<'spa
 }
 export declare function VisuallyHidden({ className, ...others }: VisuallyHiddenProps): JSX.Element;
 export declare namespace VisuallyHidden {
+    var classes: any;
     var displayName: string;
 }