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

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

@@ -0,0 +1,18 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+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';
+    /** If set, cursor is changed to pointer */
+    pointer?: boolean;
+}
+export type PillsInputFieldFactory = Factory<{
+    props: PillsInputFieldProps;
+    ref: HTMLInputElement;
+    stylesNames: PillsInputFieldStylesNames;
+}>;
+export declare const PillsInputField: import("../../../core").MantineComponent<{
+    props: PillsInputFieldProps;
+    ref: HTMLInputElement;
+    stylesNames: PillsInputFieldStylesNames;
+}>;

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

@@ -0,0 +1,4 @@
+export { PillsInput } from './PillsInput';
+export { PillsInputField } from './PillsInputField/PillsInputField';
+export type { PillsInputFactory, PillsInputProps } from './PillsInput';
+export type { PillsInputFieldFactory, PillsInputFieldProps, PillsInputFieldStylesNames, } from './PillsInputField/PillsInputField';

package/lib/components/PinInput/PinInput.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+import { BoxProps, ElementProps, Factory, MantineRadius, MantineSize, MantineSpacing, StylesApiProps } from '../../core';
+export type PinInputStylesNames = 'root' | 'pinInput' | 'input';
+export type PinInputCssVariables = {
+    root: '--pin-input-size';
+};
+export interface PinInputProps extends BoxProps, StylesApiProps<PinInputFactory>, ElementProps<'div', 'onChange'> {
+    /** Hidden input name attribute */
+    name?: string;
+    /** Hidden input form attribute */
+    form?: string;
+    /** Key of `theme.spacing` or any valid CSS value for `gap`, numbers are converted to rem, `'md'` by default */
+    gap?: MantineSpacing | (string & {}) | number;
+    /** 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;
+    /** Controls inputs `width` and `height`, `'sm'` by default */
+    size?: MantineSize;
+    /** If set, the first input is focused when component is mounted, `false` by default */
+    autoFocus?: boolean;
+    /** Controlled component value */
+    value?: string;
+    /** Uncontrolled component default value */
+    defaultValue?: string;
+    /** Called when value changes */
+    onChange?(value: string): void;
+    /** Called when all inputs have value */
+    onComplete?(value: string): void;
+    /** Inputs placeholder, `'○'` by default */
+    placeholder?: string;
+    /** Determines whether focus should be moved automatically to the next input once filled, `true` by default */
+    manageFocus?: boolean;
+    /** Determines whether `autocomplete="one-time-code"` attribute should be set on all inputs, `true` by default */
+    oneTimeCode?: boolean;
+    /** Base id used for all inputs, generated randomly by default */
+    id?: string;
+    /** Disables all inputs */
+    disabled?: boolean;
+    /** Adds error styles to all inputs */
+    error?: boolean;
+    /** Allowed values, `'alphanumeric'` by default */
+    type?: 'alphanumeric' | 'number' | RegExp;
+    /** Changes input type to `"password"`, `false` by default */
+    mask?: boolean;
+    /** Number of input boxes, `4` by default */
+    length?: number;
+    /** Determines whether input content can be edited */
+    readOnly?: boolean;
+    /** Inputs `type` attribute, inferred from the `type` prop if not specified */
+    inputType?: React.HTMLInputTypeAttribute;
+    /** `inputmode` attribute, inferred from the `type` prop if not specified */
+    inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search' | undefined;
+    /** `aria-label` for the inputs */
+    ariaLabel?: string;
+}
+export type PinInputFactory = Factory<{
+    props: PinInputProps;
+    ref: HTMLInputElement;
+    stylesNames: PinInputStylesNames;
+    vars: PinInputCssVariables;
+}>;
+export declare const PinInput: import("../../core").MantineComponent<{
+    props: PinInputProps;
+    ref: HTMLInputElement;
+    stylesNames: PinInputStylesNames;
+    vars: PinInputCssVariables;
+}>;

package/lib/components/PinInput/create-pin-array/create-pin-array.d.ts

@@ -0,0 +1 @@
+export declare function createPinArray(length: number, value: string): string[];

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

@@ -0,0 +1,2 @@
+export { PinInput } from './PinInput';
+export type { PinInputProps, PinInputStylesNames, PinInputFactory } from './PinInput';

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

@@ -26,7 +26,7 @@ interface PopoverContext {
     withinPortal: boolean | undefined;
     portalProps?: Omit<PortalProps, 'children'>;
     closeOnEscape: boolean | undefined;
-    zIndex: React.CSSProperties['zIndex'];
+    zIndex: string | number | undefined;
     radius?: MantineRadius | (string & {}) | number | undefined;
     shadow?: MantineShadow | (string & {}) | undefined;
     onClose?(): void;
@@ -49,5 +49,5 @@ interface PopoverContext {
 export declare const PopoverContextProvider: ({ children, value }: {
     value: PopoverContext;
     children: import("react").ReactNode;
-}) => JSX.Element, usePopoverContext: () => PopoverContext;
+}) => import("react/jsx-runtime").JSX.Element, usePopoverContext: () => PopoverContext;
 export {};

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

@@ -21,9 +21,9 @@ export interface __PopoverProps {
     onClose?(): void;
     /** Called when dropdown opens */
     onOpen?(): void;
-    /** If set dropdown will not be unmounted from the DOM when it is hidden, display: none styles will be added instead */
+    /** If set dropdown will not be unmounted from the DOM when it is hidden, `display: none` styles will be added instead, `false` by default */
     keepMounted?: boolean;
-    /** Props added to `Transition` component that used to animate dropdown presence, use to configure duration and animation type, `{ duration: 150, transition: 'fade' }` by default */
+    /** Props passed down to the `Transition` component that used to animate dropdown presence, use to configure duration and animation type, `{ duration: 150, transition: 'fade' }` by default */
     transitionProps?: TransitionOverride;
     /** Dropdown width, or `'target'` to make dropdown width the same as target element, `'max-content'` by default */
     width?: PopoverWidth;
@@ -35,46 +35,46 @@ export interface __PopoverProps {
     arrowSize?: number;
     /** Arrow offset in px, `5` by default */
     arrowOffset?: number;
-    /** Arrow border-radius in px, `0` by default */
+    /** Arrow `border-radius` in px, `0` by default */
     arrowRadius?: number;
-    /** Arrow position **/
+    /** Arrow position */
     arrowPosition?: ArrowPosition;
-    /** Determines whether dropdown should be rendered within Portal, `true` by default */
+    /** Determines whether dropdown should be rendered within the `Portal`, `true` by default */
     withinPortal?: boolean;
-    /** Props to pass down to the portal when withinPortal is true */
+    /** Props to pass down to the `Portal` when `withinPortal` is true */
     portalProps?: Omit<PortalProps, 'children'>;
-    /** Dropdown z-index */
-    zIndex?: React.CSSProperties['zIndex'];
+    /** Dropdown `z-index`, `300` by default */
+    zIndex?: string | number;
     /** Key of `theme.radius` or any valid CSS value to set border-radius, `theme.defaultRadius` by default */
     radius?: MantineRadius | (string & {}) | number;
-    /** Key of theme.shadow or any other valid css box-shadow value */
+    /** Key of `theme.shadows` or any other valid CSS `box-shadow` value */
     shadow?: MantineShadow | (string & {});
-    /** If set, popover dropdown will not render */
+    /** If set, popover dropdown will not be rendered */
     disabled?: boolean;
-    /** Determines whether focus should be automatically returned to control when dropdown closes, false by default */
+    /** Determines whether focus should be automatically returned to control when dropdown closes, `false` by default */
     returnFocus?: boolean;
 }
 export interface PopoverProps extends __PopoverProps, StylesApiProps<PopoverFactory> {
     __staticSelector?: string;
-    /** Popover.Target and Popover.Dropdown components */
-    children: React.ReactNode;
+    /** `Popover.Target` and `Popover.Dropdown` components */
+    children?: React.ReactNode;
     /** Initial opened state for uncontrolled component */
     defaultOpened?: boolean;
-    /** Controls dropdown opened state */
+    /** Controlled dropdown opened state */
     opened?: boolean;
     /** Called with current state when dropdown opens or closes */
     onChange?(opened: boolean): void;
-    /** Determines whether dropdown should be closed on outside clicks, default to true */
+    /** Determines whether dropdown should be closed on outside clicks, `true` by default */
     closeOnClickOutside?: boolean;
     /** Events that trigger outside clicks */
     clickOutsideEvents?: string[];
-    /** Determines whether focus should be trapped within dropdown, default to false */
+    /** Determines whether focus should be trapped within dropdown, `false` by default */
     trapFocus?: boolean;
-    /** Determines whether dropdown should be closed when Escape key is pressed, defaults to true */
+    /** Determines whether dropdown should be closed when `Escape` key is pressed, `true` by default */
     closeOnEscape?: boolean;
     /** id base to create accessibility connections */
     id?: string;
-    /** Determines whether dropdown and target element should have accessible roles, defaults to true */
+    /** Determines whether dropdown and target elements should have accessible roles, `true` by default */
     withRoles?: boolean;
 }
 export type PopoverFactory = Factory<{
@@ -82,7 +82,7 @@ export type PopoverFactory = Factory<{
     stylesNames: PopoverStylesNames;
     vars: PopoverCssVariables;
 }>;
-export declare function Popover(_props: PopoverProps): JSX.Element;
+export declare function Popover(_props: PopoverProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Popover {
     var Target: import("../../core").MantineComponent<{
         props: import("./PopoverTarget/PopoverTarget").PopoverTargetProps;

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

@@ -1,4 +1,6 @@
 export { Popover } from './Popover';
+export { PopoverDropdown } from './PopoverDropdown/PopoverDropdown';
+export { PopoverTarget } from './PopoverTarget/PopoverTarget';
 export type { PopoverFactory, PopoverProps, __PopoverProps, PopoverStylesNames } from './Popover';
 export type { PopoverTargetProps } from './PopoverTarget/PopoverTarget';
 export type { PopoverDropdownProps } from './PopoverDropdown/PopoverDropdown';

package/lib/components/Popover/use-popover.d.ts

@@ -21,33 +21,39 @@ export declare function usePopover(options: UsePopoverOptions): {
         placement: import("@floating-ui/react").Placement;
         strategy: import("@floating-ui/react").Strategy;
         middlewareData: import("@floating-ui/react").MiddlewareData;
-        x: number | null;
-        y: number | null;
+        x: number;
+        y: number;
+        isPositioned: boolean;
         update: () => void;
-        reference: (node: import("@floating-ui/react").ReferenceType | null) => void;
-        floating: (node: HTMLElement | null) => void;
-        positionReference: (node: import("@floating-ui/react").ReferenceType | null) => void;
+        floatingStyles: import("react").CSSProperties;
+        refs: {
+            reference: import("react").MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+            floating: import("react").MutableRefObject<HTMLElement | null>;
+            setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+            setFloating: (node: HTMLElement | null) => void;
+        } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: {
+            reference: import("@floating-ui/react-dom").ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
         context: {
-            x: number | null;
-            y: number | null;
-            floating: (node: HTMLElement | null) => void;
+            x: number;
+            y: number;
             placement: import("@floating-ui/react").Placement;
             strategy: import("@floating-ui/react").Strategy;
             middlewareData: import("@floating-ui/react").MiddlewareData;
-            update: () => void;
-            reference: (node: import("@floating-ui/react").ReferenceType | null) => void;
             isPositioned: boolean;
+            update: () => void;
+            floatingStyles: import("react").CSSProperties;
             open: boolean;
-            onOpenChange: (open: boolean) => void;
+            onOpenChange: (open: boolean, event?: Event | undefined) => void;
             events: import("@floating-ui/react").FloatingEvents;
             dataRef: import("react").MutableRefObject<import("@floating-ui/react").ContextData>;
             nodeId: string | undefined;
+            floatingId: string;
             refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
             elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
         };
-        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
-        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
-        isPositioned: boolean;
     };
     controlled: boolean;
     opened: boolean;

package/lib/components/Portal/OptionalPortal.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="react" />
 import { PortalProps } from './Portal';
 export interface OptionalPortalProps extends PortalProps {
     /** Determines whether children should be rendered inside `<Portal />` */
     withinPortal?: boolean;
 }
-export declare function OptionalPortal({ withinPortal, children, ...others }: OptionalPortalProps): JSX.Element;
+export declare function OptionalPortal({ withinPortal, children, ...others }: OptionalPortalProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace OptionalPortal {
     var displayName: string;
 }

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;
+}) => import("react/jsx-runtime").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;
+}) => import("react/jsx-runtime").JSX.Element, useRatingContext: () => RatingContextValue;
+export {};

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

@@ -0,0 +1,48 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineSize, MantineColor } from '../../core';
+export type RatingStylesNames = 'root' | 'starSymbol' | 'input' | 'label' | 'symbolBody' | 'symbolGroup';
+export type RatingCssVariables = {
+    root: '--rating-size' | '--rating-color';
+};
+export interface RatingProps extends BoxProps, StylesApiProps<RatingFactory>, ElementProps<'div', 'onChange'> {
+    /** Default value for uncontrolled component */
+    defaultValue?: number;
+    /** Value for controlled component */
+    value?: number;
+    /** Called when value changes */
+    onChange?(value: number): void;
+    /** The icon that is displayed when symbol is empty */
+    emptySymbol?: React.ReactNode | ((value: number) => React.ReactNode);
+    /** This icon that is displayed when symbol is full */
+    fullSymbol?: React.ReactNode | ((value: number) => React.ReactNode);
+    /** Number of fractions each item can be divided into, 1 by default */
+    fractions?: number;
+    /** Controls component size */
+    size?: MantineSize;
+    /** Number of controls that should be rendered */
+    count?: number;
+    /** Called when item is hovered */
+    onHover?(value: number): void;
+    /** Function should return labelText for the symbols */
+    getSymbolLabel?: (value: number) => string;
+    /** Name of rating, should be unique within the page */
+    name?: string;
+    /** If true, you won't be able to interact */
+    readOnly?: boolean;
+    /** If true, only the selected symbol will change to full symbol */
+    highlightSelectedOnly?: boolean;
+    /** Key of theme.colors or any CSS color value, yellow by default */
+    color?: MantineColor;
+}
+export type RatingFactory = Factory<{
+    props: RatingProps;
+    ref: HTMLDivElement;
+    stylesNames: RatingStylesNames;
+    vars: RatingCssVariables;
+}>;
+export declare const Rating: import("../../core").MantineComponent<{
+    props: RatingProps;
+    ref: HTMLDivElement;
+    stylesNames: RatingStylesNames;
+    vars: RatingCssVariables;
+}>;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { MantineSize, BoxProps, ElementProps } from '../../../core';
+export interface RatingItemProps extends BoxProps, ElementProps<'input', 'value' | 'size'> {
+    size: MantineSize;
+    getSymbolLabel: ((value: number) => string) | undefined;
+    emptyIcon?: React.ReactNode | ((value: number) => React.ReactNode);
+    fullIcon?: React.ReactNode | ((value: number) => React.ReactNode);
+    full: boolean;
+    active: boolean;
+    fractionValue: number;
+    value: number;
+    id: string;
+    onChange(event: React.ChangeEvent<HTMLInputElement> | number): void;
+}
+export declare function RatingItem({ size, getSymbolLabel, emptyIcon, fullIcon, full, active, value, readOnly, fractionValue, color, id, onChange, style, ...others }: RatingItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace RatingItem {
+    var displayName: string;
+}

package/lib/components/Rating/StarSymbol/StarIcon.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function StarIcon(props: React.ComponentPropsWithoutRef<'svg'>): import("react/jsx-runtime").JSX.Element;
+export declare namespace StarIcon {
+    var displayName: string;
+}

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

@@ -0,0 +1,7 @@
+export interface StarSymbolProps {
+    type: 'empty' | 'full';
+}
+export declare function StarSymbol({ type }: StarSymbolProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace StarSymbol {
+    var displayName: string;
+}

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

@@ -0,0 +1,2 @@
+export { Rating } from './Rating';
+export type { RatingCssVariables, RatingFactory, RatingProps, RatingStylesNames } from './Rating';

package/lib/components/RingProgress/Curve/Curve.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { MantineColor, GetStylesApi } from '../../../core';
+import type { RingProgressFactory } from '../RingProgress';
+interface CurveProps extends React.ComponentPropsWithRef<'circle'> {
+    value?: number;
+    size: number;
+    offset: number;
+    sum: number;
+    thickness: number;
+    lineRoundCaps: boolean | undefined;
+    root?: boolean;
+    color?: MantineColor;
+    tooltip?: React.ReactNode;
+    getStyles: GetStylesApi<RingProgressFactory>;
+}
+export declare function Curve({ size, value, offset, sum, thickness, root, color, lineRoundCaps, tooltip, getStyles, display, ...others }: CurveProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Curve {
+    var displayName: string;
+}
+export {};

package/lib/components/RingProgress/Curve/get-curve-props.d.ts

@@ -0,0 +1,18 @@
+interface GetCurveProps {
+    size: number;
+    thickness: number;
+    sum: number;
+    value: number | undefined;
+    root: boolean | undefined;
+    offset: number;
+}
+export declare function getCurveProps({ size, thickness, sum, value, root, offset }: GetCurveProps): {
+    strokeWidth: number;
+    cx: number;
+    cy: number;
+    r: number;
+    transform: string | undefined;
+    strokeDasharray: string;
+    strokeDashoffset: number;
+};
+export {};

package/lib/components/RingProgress/RingProgress.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineColor } from '../../core';
+interface RingProgressSection extends React.ComponentPropsWithRef<'circle'> {
+    value: number;
+    color: MantineColor;
+    tooltip?: React.ReactNode;
+}
+export type RingProgressStylesNames = 'root' | 'svg' | 'label' | 'curve';
+export type RingProgressCssVariables = {
+    root: '--rp-size' | '--rp-label-offset';
+};
+export interface RingProgressProps extends BoxProps, StylesApiProps<RingProgressFactory>, ElementProps<'div'> {
+    /** Label displayed in the center of the ring */
+    label?: React.ReactNode;
+    /** Ring thickness */
+    thickness?: number;
+    /** Width and height of the progress ring */
+    size?: number;
+    /** Sets whether the edges of the progress circle are rounded */
+    roundCaps?: boolean;
+    /** Ring sections */
+    sections: RingProgressSection[];
+    /** Color of the root section, key of theme.colors or CSS color value */
+    rootColor?: MantineColor;
+}
+export type RingProgressFactory = Factory<{
+    props: RingProgressProps;
+    ref: HTMLDivElement;
+    stylesNames: RingProgressStylesNames;
+    vars: RingProgressCssVariables;
+}>;
+export declare const RingProgress: import("../../core").MantineComponent<{
+    props: RingProgressProps;
+    ref: HTMLDivElement;
+    stylesNames: RingProgressStylesNames;
+    vars: RingProgressCssVariables;
+}>;
+export {};

package/lib/components/RingProgress/get-curves/get-curves.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { MantineColor } from '../../../core';
+interface CurveData extends React.ComponentPropsWithRef<'circle'> {
+    value: number;
+    color: MantineColor;
+    tooltip?: React.ReactNode;
+}
+interface RootCurveData extends React.ComponentPropsWithRef<'circle'> {
+    color?: MantineColor;
+}
+interface GetCurves {
+    sections: CurveData[];
+    size: number;
+    thickness: number;
+    renderRoundedLineCaps: boolean | undefined;
+    rootColor?: MantineColor;
+}
+interface Curve {
+    sum: number;
+    offset: number;
+    root: boolean;
+    data: CurveData | RootCurveData;
+    lineRoundCaps?: boolean;
+}
+export declare function getCurves({ size, thickness, sections, renderRoundedLineCaps, rootColor, }: GetCurves): Curve[];
+export {};

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

@@ -0,0 +1,2 @@
+export { RingProgress } from './RingProgress';
+export type { RingProgressCssVariables, RingProgressFactory, RingProgressProps, RingProgressStylesNames, } from './RingProgress';