@mantine/core 7.0.0-alpha.17 → 7.0.0-alpha.19

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.d.ts

@@ -9,7 +9,6 @@ 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 {
     __staticSelector?: string;
@@ -31,7 +30,6 @@ export type ModalFactory = Factory<{
     ref: HTMLDivElement;
     stylesNames: ModalStylesNames;
     vars: ModalCssVariables;
-    variant: ModalVariant;
     staticComponents: {
         Root: typeof ModalRoot;
         Overlay: typeof ModalOverlay;
@@ -47,7 +45,6 @@ export declare const Modal: import("../../core").MantineComponent<{
     ref: HTMLDivElement;
     stylesNames: ModalStylesNames;
     vars: ModalCssVariables;
-    variant: ModalVariant;
     staticComponents: {
         Root: typeof ModalRoot;
         Overlay: typeof ModalOverlay;

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

@@ -3,7 +3,6 @@ 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';
 };
@@ -27,7 +26,6 @@ export type ModalRootFactory = Factory<{
     ref: HTMLDivElement;
     stylesNames: ModalRootStylesNames;
     vars: ModalRootCssVariables;
-    variant: ModalRootVariant;
     compound: true;
 }>;
 export declare const ModalRoot: import("../../core").MantineComponent<{
@@ -35,6 +33,5 @@ export declare const ModalRoot: import("../../core").MantineComponent<{
     ref: HTMLDivElement;
     stylesNames: ModalRootStylesNames;
     vars: ModalRootCssVariables;
-    variant: ModalRootVariant;
     compound: true;
 }>;

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

@@ -6,7 +6,7 @@ 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 { ModalCssVariables, ModalFactory, ModalProps, ModalStylesNames } from './Modal';
 export type { ModalRootProps } from './ModalRoot';
 export type { ModalBodyProps } from './ModalBody';
 export type { ModalCloseButtonProps } from './ModalCloseButton';

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

@@ -1,7 +1,6 @@
 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';
 };
@@ -33,12 +32,10 @@ export type NotificationFactory = Factory<{
     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

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

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

@@ -1,7 +1,6 @@
 import React from 'react';
 import { BoxProps, StylesApiProps, PolymorphicFactory, MantineRadius } from '../../core';
 export type OverlayStylesNames = 'root';
-export type OverlayVariant = string;
 export type OverlayCssVariables = {
     root: '--overlay-bg' | '--overlay-filter' | '--overlay-radius' | '--overlay-z-index';
 };
@@ -31,7 +30,6 @@ export type OverlayFactory = PolymorphicFactory<{
     defaultComponent: 'div';
     stylesNames: OverlayStylesNames;
     vars: OverlayCssVariables;
-    variant: OverlayVariant;
 }>;
 export declare const Overlay: (<C = "div">(props: import("../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, OverlayProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(OverlayProps & {
     component?: any;
@@ -45,12 +43,10 @@ export declare const Overlay: (<C = "div">(props: import("../../core/factory/cre
     defaultComponent: 'div';
     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/Overlay/index.d.ts

@@ -1,2 +1,2 @@
 export { Overlay } from './Overlay';
-export type { OverlayCssVariables, OverlayFactory, OverlayProps, OverlayStylesNames, OverlayVariant, } from './Overlay';
+export type { OverlayCssVariables, OverlayFactory, OverlayProps, OverlayStylesNames, } from './Overlay';

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

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import type { PaginationRootFactory } from './PaginationRoot/PaginationRoot';
+interface PaginationContext {
+    total: number;
+    range: (number | 'dots')[];
+    active: number;
+    disabled: boolean | undefined;
+    getItemProps?(page: number): Record<string, any>;
+    onChange(page: number): void;
+    onNext(): void;
+    onPrevious(): void;
+    onFirst(): void;
+    onLast(): void;
+    getStyles: GetStylesApi<PaginationRootFactory>;
+}
+export declare const PaginationProvider: ({ children, value }: {
+    value: PaginationContext;
+    children: import("react").ReactNode;
+}) => JSX.Element, usePaginationContext: () => PaginationContext;
+export {};

package/lib/components/Pagination/Pagination.d.ts

@@ -0,0 +1,61 @@
+import { Factory, MantineSize } from '../../core';
+import { PaginationRoot, PaginationRootCssVariables, PaginationRootProps, PaginationRootStylesNames } from './PaginationRoot/PaginationRoot';
+import { PaginationControl } from './PaginationControl/PaginationControl';
+import { PaginationDots } from './PaginationDots/PaginationDots';
+import { PaginationFirst, PaginationLast, PaginationNext, PaginationPrevious } from './PaginationEdges/PaginationEdges';
+import { PaginationItems } from './PaginationItems/PaginationItems';
+import { PaginationIcon } from './Pagination.icons';
+export type PaginationStylesNames = PaginationRootStylesNames;
+export type PaginationCssVariables = PaginationRootCssVariables;
+export interface PaginationProps extends PaginationRootProps {
+    /** Determines whether first/last controls should be rendered, false by default */
+    withEdges?: boolean;
+    /** Determines whether next/previous controls should be rendered, true by default */
+    withControls?: boolean;
+    /** Adds props to next/previous/first/last controls */
+    getControlProps?(control: 'first' | 'previous' | 'last' | 'next'): Record<string, any>;
+    /** Next control icon component */
+    nextIcon?: PaginationIcon;
+    /** Previous control icon component */
+    previousIcon?: PaginationIcon;
+    /** Last control icon component */
+    lastIcon?: PaginationIcon;
+    /** First control icon component */
+    firstIcon?: PaginationIcon;
+    /** Dots icon component */
+    dotsIcon?: PaginationIcon;
+    /** Key of `theme.spacing`, gap between controls, `8` by default */
+    gap?: MantineSize | (string & {}) | number;
+}
+export type PaginationFactory = Factory<{
+    props: PaginationProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationStylesNames;
+    vars: PaginationCssVariables;
+    staticComponents: {
+        Root: typeof PaginationRoot;
+        Control: typeof PaginationControl;
+        Dots: typeof PaginationDots;
+        First: typeof PaginationFirst;
+        Last: typeof PaginationLast;
+        Next: typeof PaginationNext;
+        Previous: typeof PaginationPrevious;
+        Items: typeof PaginationItems;
+    };
+}>;
+export declare const Pagination: import("../../core").MantineComponent<{
+    props: PaginationProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationStylesNames;
+    vars: PaginationCssVariables;
+    staticComponents: {
+        Root: typeof PaginationRoot;
+        Control: typeof PaginationControl;
+        Dots: typeof PaginationDots;
+        First: typeof PaginationFirst;
+        Last: typeof PaginationLast;
+        Next: typeof PaginationNext;
+        Previous: typeof PaginationPrevious;
+        Items: typeof PaginationItems;
+    };
+}>;

package/lib/components/Pagination/Pagination.icons.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface _PaginationIconProps extends React.ComponentPropsWithoutRef<'svg'> {
+    path: string;
+}
+export type PaginationIconProps = Omit<_PaginationIconProps, 'path'>;
+export type PaginationIcon = React.FC<PaginationIconProps>;
+export declare const PaginationNextIcon: (props: PaginationIconProps) => JSX.Element;
+export declare const PaginationPreviousIcon: (props: PaginationIconProps) => JSX.Element;
+export declare const PaginationFirstIcon: (props: PaginationIconProps) => JSX.Element;
+export declare const PaginationLastIcon: (props: PaginationIconProps) => JSX.Element;
+export declare const PaginationDotsIcon: (props: PaginationIconProps) => JSX.Element;
+export {};

package/lib/components/Pagination/PaginationControl/PaginationControl.d.ts

@@ -0,0 +1,20 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type PaginationControlStylesNames = 'control';
+export interface PaginationControlProps extends BoxProps, StylesApiProps<PaginationControlFactory>, ElementProps<'button'> {
+    /** Determines whether control should have active styles */
+    active?: boolean;
+    /** Determines whether control should have padding, true by default */
+    withPadding?: boolean;
+}
+export type PaginationControlFactory = Factory<{
+    props: PaginationControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: PaginationControlStylesNames;
+    compound: true;
+}>;
+export declare const PaginationControl: import("../../../core").MantineComponent<{
+    props: PaginationControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: PaginationControlStylesNames;
+    compound: true;
+}>;

package/lib/components/Pagination/PaginationDots/PaginationDots.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+import { PaginationIconProps } from '../Pagination.icons';
+export type PaginationDotsStylesNames = 'dots';
+export interface PaginationDotsProps extends BoxProps, StylesApiProps<PaginationDotsFactory>, ElementProps<'div'> {
+    /** Custom dots icon component, must accept svg element props and size prop */
+    icon?: React.FC<PaginationIconProps>;
+}
+export type PaginationDotsFactory = Factory<{
+    props: PaginationDotsProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationDotsStylesNames;
+    compound: true;
+}>;
+export declare const PaginationDots: import("../../../core").MantineComponent<{
+    props: PaginationDotsProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationDotsStylesNames;
+    compound: true;
+}>;

package/lib/components/Pagination/PaginationEdges/PaginationEdges.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { BoxProps } from '../../../core';
+import { PaginationIconProps } from '../Pagination.icons';
+export interface CreateEdgeComponent {
+    icon: React.FC<PaginationIconProps>;
+    name: string;
+    action: 'onNext' | 'onPrevious' | 'onFirst' | 'onLast';
+    type: 'next' | 'previous';
+}
+export interface PaginationEdgeProps extends BoxProps {
+    icon?: React.FC<PaginationIconProps>;
+}
+export declare function createEdgeComponent({ icon, name, action, type }: CreateEdgeComponent): (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaginationEdgeProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaginationEdgeProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaginationEdgeProps> & {
+    ref?: any;
+}) | (PaginationEdgeProps & {
+    component: React.ElementType<any>;
+})>, never> & Record<string, never>;
+export declare const PaginationNext: (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaginationEdgeProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaginationEdgeProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaginationEdgeProps> & {
+    ref?: any;
+}) | (PaginationEdgeProps & {
+    component: React.ElementType<any>;
+})>, never> & Record<string, never>;
+export declare const PaginationPrevious: (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaginationEdgeProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaginationEdgeProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaginationEdgeProps> & {
+    ref?: any;
+}) | (PaginationEdgeProps & {
+    component: React.ElementType<any>;
+})>, never> & Record<string, never>;
+export declare const PaginationFirst: (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaginationEdgeProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaginationEdgeProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaginationEdgeProps> & {
+    ref?: any;
+}) | (PaginationEdgeProps & {
+    component: React.ElementType<any>;
+})>, never> & Record<string, never>;
+export declare const PaginationLast: (<C = "button">(props: import("../../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaginationEdgeProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaginationEdgeProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaginationEdgeProps> & {
+    ref?: any;
+}) | (PaginationEdgeProps & {
+    component: React.ElementType<any>;
+})>, never> & Record<string, never>;

package/lib/components/Pagination/PaginationItems/PaginationItems.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { PaginationIcon } from '../Pagination.icons';
+export interface PaginationItemsProps {
+    /** Dots icon component */
+    dotsIcon?: PaginationIcon;
+}
+export declare function PaginationItems({ dotsIcon }: PaginationItemsProps): JSX.Element;
+export declare namespace PaginationItems {
+    var displayName: string;
+}

package/lib/components/Pagination/PaginationRoot/PaginationRoot.d.ts

@@ -0,0 +1,49 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineSize, MantineColor, MantineRadius } from '../../../core';
+export type PaginationRootStylesNames = 'root' | 'control' | 'dots';
+export type PaginationRootCssVariables = {
+    root: '--pagination-control-size' | '--pagination-control-radius' | '--pagination-control-fz' | '--pagination-active-bg';
+};
+export interface PaginationRootProps extends BoxProps, StylesApiProps<PaginationRootFactory>, ElementProps<'div', 'value' | 'onChange'> {
+    /** `height` and `min-width` of controls, `'md'` by default */
+    size?: MantineSize | (string & {}) | number;
+    /** Total number of pages, must be an integer */
+    total: number;
+    /** Active page for controlled component, must be an integer in [0, total] interval */
+    value?: number;
+    /** Active page for uncontrolled component, must be an integer in [0, total] interval */
+    defaultValue?: number;
+    /** Called when page changes */
+    onChange?(value: number): void;
+    /** Determines whether all controls should be disabled, `false` by default */
+    disabled?: boolean;
+    /** Number of siblings displayed on the left/right side of the selected page, `1` by default */
+    siblings?: number;
+    /** Number of elements visible on the left/right edges, `1` by default */
+    boundaries?: number;
+    /** Key of `theme.colors`, active item color, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, numbers are converted to rem, `theme.defaultRadius` by default */
+    radius?: MantineRadius | (string & {}) | number;
+    /** Called when next page control is clicked */
+    onNextPage?(): void;
+    /** Called when previous page control is clicked */
+    onPreviousPage?(): void;
+    /** Called when first page control is clicked */
+    onFirstPage?(): void;
+    /** Called when last page control is clicked */
+    onLastPage?(): void;
+    /** Additional props passed down to controls */
+    getItemProps?(page: number): Record<string, any>;
+}
+export type PaginationRootFactory = Factory<{
+    props: PaginationRootProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationRootStylesNames;
+    vars: PaginationRootCssVariables;
+}>;
+export declare const PaginationRoot: import("../../../core").MantineComponent<{
+    props: PaginationRootProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationRootStylesNames;
+    vars: PaginationRootCssVariables;
+}>;

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

@@ -0,0 +1,12 @@
+export { Pagination } from './Pagination';
+export { PaginationControl } from './PaginationControl/PaginationControl';
+export { PaginationDots } from './PaginationDots/PaginationDots';
+export { PaginationFirst, PaginationLast, PaginationNext, PaginationPrevious, } from './PaginationEdges/PaginationEdges';
+export { PaginationItems } from './PaginationItems/PaginationItems';
+export { PaginationRoot } from './PaginationRoot/PaginationRoot';
+export type { PaginationCssVariables, PaginationFactory, PaginationProps, PaginationStylesNames, } from './Pagination';
+export type { PaginationRootProps } from './PaginationRoot/PaginationRoot';
+export type { PaginationControlProps } from './PaginationControl/PaginationControl';
+export type { PaginationDotsProps } from './PaginationDots/PaginationDots';
+export type { PaginationEdgeProps } from './PaginationEdges/PaginationEdges';
+export type { PaginationItemsProps } from './PaginationItems/PaginationItems';

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

@@ -1,7 +1,6 @@
 import React from 'react';
 import { BoxProps, StylesApiProps, MantineShadow, MantineRadius, PolymorphicFactory } from '../../core';
 export type PaperStylesNames = 'root';
-export type PaperVariant = string;
 export type PaperCssVariables = {
     root: '--paper-radius' | '--paper-shadow';
 };

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

@@ -1,2 +1,2 @@
 export { Paper } from './Paper';
-export type { PaperProps, PaperStylesNames, PaperCssVariables, PaperFactory, PaperVariant, } from './Paper';
+export type { PaperProps, PaperStylesNames, PaperCssVariables, PaperFactory } from './Paper';

package/lib/components/Pill/PillGroup/PillGroup.d.ts

@@ -1,7 +1,7 @@
 import { BoxProps, StylesApiProps, ElementProps, Factory, MantineSize } from '../../../core';
-export type PillGroupStylesNames = 'root';
+export type PillGroupStylesNames = 'group';
 export type PillGroupCssVariables = {
-    root: '--pg-gap';
+    group: '--pg-gap';
 };
 export interface PillGroupProps extends BoxProps, StylesApiProps<PillGroupFactory>, ElementProps<'div'> {
     /** Controls spacing between pills, by default controlled by `size` */

package/lib/components/PillsInput/PillsInputField/PillsInputField.d.ts

@@ -1,5 +1,5 @@
 import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
-export type PillsInputFieldStylesNames = 'root';
+export type PillsInputFieldStylesNames = 'field';
 export interface PillsInputFieldProps extends BoxProps, StylesApiProps<PillsInputFieldFactory>, ElementProps<'input', 'type'> {
     /** Controls input styles when focused. If `auto` the input is hidden when not focused. If `visible` the input will always remain visible. `'visible'` by default  */
     type?: 'auto' | 'visible' | 'hidden';

package/lib/components/Popover/Popover.d.ts

@@ -57,7 +57,7 @@ export interface __PopoverProps {
 export interface PopoverProps extends __PopoverProps, StylesApiProps<PopoverFactory> {
     __staticSelector?: string;
     /** `Popover.Target` and `Popover.Dropdown` components */
-    children: React.ReactNode;
+    children?: React.ReactNode;
     /** Initial opened state for uncontrolled component */
     defaultOpened?: boolean;
     /** Controlled dropdown opened state */

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import type { ProgressRootFactory } from './ProgressRoot/ProgressRoot';
+interface ProgressContextValue {
+    getStyles: GetStylesApi<ProgressRootFactory>;
+}
+export declare const ProgressProvider: ({ children, value }: {
+    value: ProgressContextValue;
+    children: import("react").ReactNode;
+}) => JSX.Element, useProgressContext: () => ProgressContextValue;
+export {};

package/lib/components/Progress/Progress.d.ts

@@ -0,0 +1,37 @@
+import { StylesApiProps, Factory, MantineColor } from '../../core';
+import { ProgressRoot, ProgressRootStylesNames, ProgressRootCssVariables, __ProgressRootProps } from './ProgressRoot/ProgressRoot';
+import { ProgressSection } from './ProgressSection/ProgressSection';
+import { ProgressLabel } from './ProgressLabel/ProgressLabel';
+export type ProgressStylesNames = ProgressRootStylesNames;
+export interface ProgressProps extends __ProgressRootProps, StylesApiProps<ProgressFactory> {
+    /** Value of the progress */
+    value: number;
+    /** Key of `theme.colors` or any valid CSS value, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Determines whether the section should have stipes, `false` by default */
+    striped?: boolean;
+    /** Determines whether the sections stripes should be animated, if set, `striped` prop is ignored, `false` by default */
+    animated?: boolean;
+}
+export type ProgressFactory = Factory<{
+    props: ProgressProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressStylesNames;
+    vars: ProgressRootCssVariables;
+    staticComponents: {
+        Section: typeof ProgressSection;
+        Root: typeof ProgressRoot;
+        Label: typeof ProgressLabel;
+    };
+}>;
+export declare const Progress: import("../../core").MantineComponent<{
+    props: ProgressProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressStylesNames;
+    vars: ProgressRootCssVariables;
+    staticComponents: {
+        Section: typeof ProgressSection;
+        Root: typeof ProgressRoot;
+        Label: typeof ProgressLabel;
+    };
+}>;

package/lib/components/Progress/ProgressLabel/ProgressLabel.d.ts

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

package/lib/components/Progress/ProgressRoot/ProgressRoot.d.ts

@@ -0,0 +1,25 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineSize, MantineRadius } from '../../../core';
+export type ProgressRootStylesNames = 'root' | 'section' | 'label';
+export type ProgressRootCssVariables = {
+    root: '--progress-size' | '--progress-radius';
+};
+export interface __ProgressRootProps extends BoxProps, ElementProps<'div'> {
+    /** Controls track height, `'md'` by default */
+    size?: MantineSize | (string & {}) | number;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, `theme.defaultRadius` by default */
+    radius?: MantineRadius | (string & {}) | number;
+}
+export interface ProgressRootProps extends __ProgressRootProps, StylesApiProps<ProgressRootFactory> {
+}
+export type ProgressRootFactory = Factory<{
+    props: ProgressRootProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressRootStylesNames;
+    vars: ProgressRootCssVariables;
+}>;
+export declare const ProgressRoot: import("../../../core").MantineComponent<{
+    props: ProgressRootProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressRootStylesNames;
+    vars: ProgressRootCssVariables;
+}>;

package/lib/components/Progress/ProgressSection/ProgressSection.d.ts

@@ -0,0 +1,26 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineColor } from '../../../core';
+export type ProgressSectionStylesNames = 'section';
+export interface ProgressSectionProps extends BoxProps, StylesApiProps<ProgressSectionFactory>, ElementProps<'div'> {
+    /** Value of the section in 0–100 range  */
+    value: number;
+    /** Determines whether `aria-*` props should be added to the root element, `true` by default */
+    withAria?: boolean;
+    /** Key of `theme.colors` or any valid CSS value, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Determines whether the section should have stipes, `false` by default */
+    striped?: boolean;
+    /** Determines whether the sections stripes should be animated, if set, `striped` prop is ignored, `false` by default */
+    animated?: boolean;
+}
+export type ProgressSectionFactory = Factory<{
+    props: ProgressSectionProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressSectionStylesNames;
+    compound: true;
+}>;
+export declare const ProgressSection: import("../../../core").MantineComponent<{
+    props: ProgressSectionProps;
+    ref: HTMLDivElement;
+    stylesNames: ProgressSectionStylesNames;
+    compound: true;
+}>;

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

@@ -0,0 +1,8 @@
+export { Progress } from './Progress';
+export { ProgressLabel } from './ProgressLabel/ProgressLabel';
+export { ProgressRoot } from './ProgressRoot/ProgressRoot';
+export { ProgressSection } from './ProgressSection/ProgressSection';
+export type { ProgressFactory, ProgressProps, ProgressStylesNames } from './Progress';
+export type { ProgressLabelProps } from './ProgressLabel/ProgressLabel';
+export type { ProgressRootProps } from './ProgressRoot/ProgressRoot';
+export type { ProgressSectionProps } from './ProgressSection/ProgressSection';

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import type { RatingFactory } from './Rating';
+interface RatingContextValue {
+    getStyles: GetStylesApi<RatingFactory>;
+}
+export declare const RatingProvider: ({ children, value }: {
+    value: RatingContextValue;
+    children: import("react").ReactNode;
+}) => JSX.Element, useRatingContext: () => RatingContextValue;
+export {};