@mantine/core 8.3.13 → 9.0.0-alpha.0

package/lib/components/FloatingIndicator/FloatingIndicator.d.ts

@@ -4,26 +4,42 @@ export type FloatingIndicatorCssVariables = {
     root: '--transition-duration';
 };
 export interface FloatingIndicatorProps extends BoxProps, StylesApiProps<FloatingIndicatorFactory>, ElementProps<'div'> {
-    /** Target element over which indicator is displayed */
+    /** Target element over which the indicator is displayed.
+     * The indicator will be positioned to match the target's size and position.
+     * */
     target: HTMLElement | null | undefined;
-    /** Parent element with relative position based on which indicator position is calculated */
+    /** Parent container element that must have `position: relative`.
+     * The indicator's position is calculated relative to this element.
+     * */
     parent: HTMLElement | null | undefined;
-    /** Transition duration in ms @default `150` */
+    /** Transition duration in ms @default 150 */
     transitionDuration?: number | string;
-    /** If set, the indicator is displayed after transition ends.
-     * Should be set if the component is used inside a container that has `transform: scale(n)` styles.
+    /** Controls whether the indicator should be hidden initially and displayed after the parent's transition ends.
+     * Set to `true` when the parent container has CSS transitions (e.g., `transform: scale()`) to prevent
+     * the indicator from appearing at the wrong position during the parent's animation.
+     * @default false
      * */
     displayAfterTransitionEnd?: boolean;
+    /** Called when the indicator starts transitioning to a new position */
+    onTransitionStart?: () => void;
+    /** Called when the indicator finishes transitioning to a new position */
+    onTransitionEnd?: () => void;
 }
 export type FloatingIndicatorFactory = Factory<{
     props: FloatingIndicatorProps;
     ref: HTMLDivElement;
     stylesNames: FloatingIndicatorStylesNames;
     vars: FloatingIndicatorCssVariables;
+    ctx: {
+        shouldReduceMotion: boolean;
+    };
 }>;
 export declare const FloatingIndicator: import("../..").MantineComponent<{
     props: FloatingIndicatorProps;
     ref: HTMLDivElement;
     stylesNames: FloatingIndicatorStylesNames;
     vars: FloatingIndicatorCssVariables;
+    ctx: {
+        shouldReduceMotion: boolean;
+    };
 }>;

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

@@ -1,2 +1,9 @@
+import type { FloatingIndicatorCssVariables, FloatingIndicatorFactory, FloatingIndicatorProps, FloatingIndicatorStylesNames } from './FloatingIndicator';
 export { FloatingIndicator } from './FloatingIndicator';
-export type { FloatingIndicatorCssVariables, FloatingIndicatorFactory, FloatingIndicatorProps, FloatingIndicatorStylesNames, } from './FloatingIndicator';
+export type { FloatingIndicatorProps, FloatingIndicatorStylesNames, FloatingIndicatorCssVariables, FloatingIndicatorFactory, };
+export declare namespace FloatingIndicator {
+    type Props = FloatingIndicatorProps;
+    type StylesNames = FloatingIndicatorStylesNames;
+    type CssVariables = FloatingIndicatorCssVariables;
+    type Factory = FloatingIndicatorFactory;
+}

package/lib/components/FloatingIndicator/use-floating-indicator.d.ts

@@ -2,10 +2,12 @@ import { type RefObject } from 'react';
 interface UseFloatingIndicatorInput {
     target: HTMLElement | null | undefined;
     parent: HTMLElement | null | undefined;
-    ref: RefObject<HTMLDivElement>;
+    ref: RefObject<HTMLElement | null>;
     displayAfterTransitionEnd?: boolean;
+    onTransitionStart?: () => void;
+    onTransitionEnd?: () => void;
 }
-export declare function useFloatingIndicator({ target, parent, ref, displayAfterTransitionEnd, }: UseFloatingIndicatorInput): {
+export declare function useFloatingIndicator({ target, parent, ref, displayAfterTransitionEnd, onTransitionStart, onTransitionEnd, }: UseFloatingIndicatorInput): {
     initialized: boolean;
     hidden: boolean;
 };

package/lib/components/FloatingWindow/FloatingWindow.d.ts

@@ -0,0 +1,25 @@
+import { SetFloatingWindowPosition, UseFloatingWindowOptions } from '@mantine/hooks';
+import { BoxProps, ElementProps, Factory, StylesApiProps } from '../../core';
+import { PaperBaseProps } from '../Paper';
+import { PortalProps } from '../Portal';
+export type FloatingWindowStylesNames = 'root';
+export interface FloatingWindowProps extends UseFloatingWindowOptions, PaperBaseProps, BoxProps, StylesApiProps<FloatingWindowFactory>, ElementProps<'div', keyof UseFloatingWindowOptions> {
+    /** Assigns ref to set position programmatically */
+    setPositionRef?: React.RefObject<SetFloatingWindowPosition | null>;
+    /** Determines whether the window should be rendered inside `Portal` @default true */
+    withinPortal?: boolean;
+    /** Props passed down to `Portal` component */
+    portalProps?: Omit<PortalProps, 'children'>;
+    /** `z-index` of the root element @default 400 */
+    zIndex?: React.CSSProperties['zIndex'];
+}
+export type FloatingWindowFactory = Factory<{
+    props: FloatingWindowProps;
+    ref: HTMLDivElement;
+    stylesNames: FloatingWindowStylesNames;
+}>;
+export declare const FloatingWindow: import("../..").MantineComponent<{
+    props: FloatingWindowProps;
+    ref: HTMLDivElement;
+    stylesNames: FloatingWindowStylesNames;
+}>;

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

@@ -0,0 +1,8 @@
+import type { FloatingWindowFactory, FloatingWindowProps, FloatingWindowStylesNames } from './FloatingWindow';
+export { FloatingWindow } from './FloatingWindow';
+export type { FloatingWindowProps, FloatingWindowStylesNames, FloatingWindowFactory };
+export declare namespace FloatingWindow {
+    type Props = FloatingWindowProps;
+    type StylesNames = FloatingWindowStylesNames;
+    type Factory = FloatingWindowFactory;
+}

package/lib/components/FocusTrap/FocusTrap.d.ts

@@ -3,17 +3,20 @@ export interface FocusTrapProps {
     children: any;
     /** If set to `false`, disables focus trap */
     active?: boolean;
-    /** Prop that is used to access element ref @default `'ref'` */
+    /** Prop that is used to access element ref @default 'ref' */
     refProp?: string;
     /** Ref to combine with the focus trap ref */
-    innerRef?: React.ForwardedRef<any>;
+    innerRef?: React.Ref<any>;
 }
 export declare function FocusTrap({ children, active, refProp, innerRef, }: FocusTrapProps): React.ReactElement;
 export declare namespace FocusTrap {
     var displayName: string;
     var InitialFocus: typeof FocusTrapInitialFocus;
 }
-export declare function FocusTrapInitialFocus(props: React.ComponentPropsWithoutRef<'span'>): import("react/jsx-runtime").JSX.Element;
+export declare function FocusTrapInitialFocus(props: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
 export declare namespace FocusTrapInitialFocus {
     var displayName: string;
 }
+export declare namespace FocusTrap {
+    type Props = FocusTrapProps;
+}

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

@@ -1,15 +1,11 @@
 import { GetStylesApi, MantineSize } from '../../core';
 import type { GridFactory } from './Grid';
 export type GridBreakpoints = Record<MantineSize, string>;
-interface GridContextValue {
+export interface GridContextValue {
     getStyles: GetStylesApi<GridFactory>;
     grow: boolean | undefined;
     columns: number;
     breakpoints: GridBreakpoints | undefined;
     type: 'container' | 'media' | undefined;
 }
-export declare const GridProvider: ({ children, value }: {
-    value: GridContextValue;
-    children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element, useGridContext: () => GridContextValue;
-export {};
+export declare const GridProvider: import("react").Context<GridContextValue | null>, useGridContext: () => GridContextValue;

package/lib/components/Grid/Grid.d.ts

@@ -6,19 +6,23 @@ export type GridCssVariables = {
     root: '--grid-justify' | '--grid-align' | '--grid-overflow';
 };
 export interface GridProps extends BoxProps, StylesApiProps<GridFactory>, ElementProps<'div'> {
-    /** Gutter between columns, key of `theme.spacing` or any valid CSS value @default `'md'` */
-    gutter?: StyleProp<MantineSpacing>;
-    /** If set, columns in the last row expand to fill all available space @default `false` */
+    /** Gap between columns and rows, key of `theme.spacing` or any valid CSS value @default 'md' */
+    gap?: StyleProp<MantineSpacing>;
+    /** Row gap, overrides `gap` for vertical spacing */
+    rowGap?: StyleProp<MantineSpacing>;
+    /** Column gap, overrides `gap` for horizontal spacing */
+    columnGap?: StyleProp<MantineSpacing>;
+    /** If set, columns in the last row expand to fill all available space @default false */
     grow?: boolean;
-    /** Sets `justify-content` @default `flex-start` */
+    /** Sets `justify-content` @default flex-start */
     justify?: React.CSSProperties['justifyContent'];
-    /** Sets `align-items` @default `stretch` */
+    /** Sets `align-items` @default stretch */
     align?: React.CSSProperties['alignItems'];
-    /** Number of columns in each row @default `12` */
+    /** Number of columns in each row @default 12 */
     columns?: number;
-    /** Sets `overflow` CSS property on the root element @default `'visible'` */
+    /** Sets `overflow` CSS property on the root element @default 'visible' */
     overflow?: React.CSSProperties['overflow'];
-    /** Type of queries used for responsive styles @default `'media'` */
+    /** Type of queries used for responsive styles @default 'media' */
     type?: 'media' | 'container';
     /** Breakpoints values, only used with `type="container"` */
     breakpoints?: GridBreakpoints;

package/lib/components/Grid/GridCol/GridCol.d.ts

@@ -2,12 +2,14 @@ import { BoxProps, CompoundStylesApiProps, ElementProps, Factory, StyleProp } fr
 export type GridColStylesNames = 'col';
 export type ColSpan = number | 'auto' | 'content';
 export interface GridColProps extends BoxProps, CompoundStylesApiProps<GridColFactory>, ElementProps<'div'> {
-    /** Column span @default `12` */
+    /** Column span @default 12 */
     span?: StyleProp<ColSpan>;
-    /** Column order, can be used to reorder columns at different viewport sizes */
+    /** Column order, use to reorder columns at different viewport sizes */
     order?: StyleProp<number>;
-    /** Column offset on the left side – number of columns that are left empty before this column */
+    /** Column start offset – number of empty columns before this column */
     offset?: StyleProp<number>;
+    /** Vertical alignment of the column, controls `align-self` CSS property */
+    align?: StyleProp<React.CSSProperties['alignSelf']>;
 }
 export type GridColFactory = Factory<{
     props: GridColProps;

package/lib/components/Grid/GridCol/GridColVariables.d.ts

@@ -4,6 +4,7 @@ interface GridColVariablesProps {
     span: GridColProps['span'] | undefined;
     order?: GridColProps['order'] | undefined;
     offset?: GridColProps['offset'] | undefined;
+    align?: GridColProps['align'] | undefined;
 }
-export declare function GridColVariables({ span, order, offset, selector }: GridColVariablesProps): import("react/jsx-runtime").JSX.Element;
+export declare function GridColVariables({ span, order, offset, align, selector }: GridColVariablesProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/lib/components/Grid/GridVariables.d.ts

@@ -2,5 +2,5 @@ import type { GridProps } from './Grid';
 interface GridVariablesProps extends GridProps {
     selector: string;
 }
-export declare function GridVariables({ gutter, selector, breakpoints, type }: GridVariablesProps): import("react/jsx-runtime").JSX.Element;
+export declare function GridVariables({ gap, rowGap, columnGap, selector, breakpoints, type, }: GridVariablesProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,4 +1,18 @@
+import type { GridCssVariables, GridFactory, GridProps, GridStylesNames } from './Grid';
+import type { GridContextValue } from './Grid.context';
+import type { GridColProps } from './GridCol/GridCol';
 export { Grid } from './Grid';
 export { GridCol } from './GridCol/GridCol';
-export type { GridCssVariables, GridFactory, GridProps, GridStylesNames } from './Grid';
-export type { GridColProps } from './GridCol/GridCol';
+export { useGridContext } from './Grid.context';
+export type { GridCssVariables, GridFactory, GridProps, GridStylesNames, GridColProps, GridContextValue, };
+export declare namespace Grid {
+    type Props = GridProps;
+    type Factory = GridFactory;
+    type StylesNames = GridStylesNames;
+    type CssVariables = GridCssVariables;
+    type ColProps = GridColProps;
+    type ContextValue = GridContextValue;
+    namespace Col {
+        type Props = GridColProps;
+    }
+}

package/lib/components/Group/Group.d.ts

@@ -8,17 +8,17 @@ export interface GroupStylesCtx {
 }
 export interface GroupProps extends BoxProps, StylesApiProps<GroupFactory>, ElementProps<'div'> {
     __size?: any;
-    /** Controls `justify-content` CSS property @default `'flex-start'` */
+    /** Controls `justify-content` CSS property @default 'flex-start' */
     justify?: React.CSSProperties['justifyContent'];
-    /** Controls `align-items` CSS property @default `'center'` */
+    /** Controls `align-items` CSS property @default 'center' */
     align?: React.CSSProperties['alignItems'];
-    /** Controls `flex-wrap` CSS property @default `'wrap'` */
+    /** Controls `flex-wrap` CSS property @default 'wrap' */
     wrap?: React.CSSProperties['flexWrap'];
-    /** Key of `theme.spacing` or any valid CSS value for `gap`, numbers are converted to rem @default `'md'` */
+    /** Key of `theme.spacing` or any valid CSS value for `gap`, numbers are converted to rem @default 'md' */
     gap?: MantineSpacing;
-    /** Determines whether each child element should have `flex-grow: 1` style @default `false` */
+    /** Determines whether each child element should have `flex-grow: 1` style @default false */
     grow?: boolean;
-    /** Determines whether children should take only dedicated amount of space (`max-width` style is set based on the number of children) @default `true` */
+    /** Determines whether children should take only dedicated amount of space (`max-width` style is set based on the number of children) @default true */
     preventGrowOverflow?: boolean;
 }
 export type GroupFactory = Factory<{

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

@@ -1,2 +1,10 @@
+import type { GroupCssVariables, GroupFactory, GroupProps, GroupStylesCtx, GroupStylesNames } from './Group';
 export { Group } from './Group';
-export type { GroupCssVariables, GroupFactory, GroupStylesNames, GroupStylesCtx, GroupProps, } from './Group';
+export type { GroupCssVariables, GroupFactory, GroupProps, GroupStylesCtx, GroupStylesNames };
+export declare namespace Group {
+    type Props = GroupProps;
+    type StylesNames = GroupStylesNames;
+    type CssVariables = GroupCssVariables;
+    type StylesCtx = GroupStylesCtx;
+    type Factory = GroupFactory;
+}

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

@@ -1,14 +1,41 @@
 import { MantineColor, MantineTheme, PolymorphicFactory } from '../../core';
 import { TextProps, TextStylesNames, TextVariant } from '../Text';
+export interface HighlightTerm {
+    /** Text to highlight */
+    text: string;
+    /** Background color for this specific term. Key of `theme.colors` or any valid CSS color */
+    color?: MantineColor | string;
+}
 export interface HighlightProps extends Omit<TextProps, 'color'> {
-    /** Substring or a list of substrings to highlight in `children` */
-    highlight: string | string[];
-    /** Key of `theme.colors` or any valid CSS color, passed to `Mark` component `color` prop @default `yellow` */
+    /**
+     * Substring(s) to highlight in `children`. Can be:
+     * - string: single term
+     * - string[]: multiple terms with same color
+     * - HighlightTerm[]: multiple terms with custom colors per term
+     *
+     * - Matching is case-insensitive
+     * - Regex special characters are automatically escaped
+     * - When multiple substrings are provided, longer matches take precedence
+     * - Empty strings and whitespace-only strings are ignored
+     */
+    highlight: string | string[] | HighlightTerm[];
+    /**
+     * Default background color for all highlighted text.
+     * Key of `theme.colors` or any valid CSS color, passed to `Mark` component.
+     * Can be overridden per term when using HighlightTerm objects.
+     * @default 'yellow'
+     */
     color?: MantineColor | string;
     /** Styles applied to `mark` elements */
     highlightStyles?: React.CSSProperties | ((theme: MantineTheme) => React.CSSProperties);
-    /** String parts of which must be highlighted */
+    /** String in which to highlight substrings */
     children: string;
+    /**
+     * Only match whole words (adds word boundaries to regex).
+     * When enabled, 'the' will not match 'there'.
+     * @default false
+     */
+    wholeWord?: boolean;
 }
 export type HighlightFactory = PolymorphicFactory<{
     props: HighlightProps;
@@ -19,7 +46,7 @@ export type HighlightFactory = PolymorphicFactory<{
 }>;
 export declare const Highlight: (<C = "div">(props: import("../..").PolymorphicComponentProps<C, HighlightProps>) => React.ReactElement) & Omit<import("react").FunctionComponent<(HighlightProps & {
     component?: any;
-} & Omit<Omit<any, "ref">, "component" | keyof HighlightProps> & {
+} & Omit<any, "component" | keyof HighlightProps> & {
     ref?: any;
     renderRoot?: (props: any) => any;
 }) | (HighlightProps & {

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

@@ -1,4 +1,9 @@
-export declare function highlighter(value: string, _highlight: string | string[]): {
+export interface HighlightChunk {
     chunk: string;
     highlighted: boolean;
-}[];
+    color?: string;
+}
+export interface HighlighterOptions {
+    wholeWord?: boolean;
+}
+export declare function highlighter(value: string, _highlight: string | string[], options?: HighlighterOptions): HighlightChunk[];

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

@@ -1,2 +1,8 @@
+import type { HighlightFactory, HighlightProps, HighlightTerm } from './Highlight';
 export { Highlight } from './Highlight';
-export type { HighlightFactory, HighlightProps } from './Highlight';
+export type { HighlightProps, HighlightFactory, HighlightTerm };
+export declare namespace Highlight {
+    type Props = HighlightProps;
+    type Factory = HighlightFactory;
+    type Term = HighlightTerm;
+}

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

@@ -1,4 +1,4 @@
-interface HoverCardContext {
+export interface HoverCardContextValue {
     openDropdown: () => void;
     closeDropdown: () => void;
     getReferenceProps?: () => any;
@@ -6,8 +6,4 @@ interface HoverCardContext {
     reference?: (node: HTMLElement | null) => void;
     floating?: (node: HTMLElement | null) => void;
 }
-export declare const HoverCardContextProvider: ({ children, value }: {
-    value: HoverCardContext;
-    children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element, useHoverCardContext: () => HoverCardContext;
-export {};
+export declare const HoverCardContext: import("react").Context<HoverCardContextValue | null>, useHoverCardContext: () => HoverCardContextValue;

package/lib/components/HoverCard/HoverCard.d.ts

@@ -1,19 +1,28 @@
 import { ExtendComponent, Factory } from '../../core';
 import { PopoverProps, PopoverStylesNames } from '../Popover';
 import { PopoverCssVariables } from '../Popover/Popover';
-import { HoverCardDropdown } from './HoverCardDropdown/HoverCardDropdown';
-import { HoverCardGroup } from './HoverCardGroup/HoverCardGroup';
+import { HoverCardContextValue } from './HoverCard.context';
+import { HoverCardDropdown, HoverCardDropdownProps } from './HoverCardDropdown/HoverCardDropdown';
+import { HoverCardGroup, HoverCardGroupContextValue, HoverCardGroupProps } from './HoverCardGroup/HoverCardGroup';
+import { HoverCardTarget, HoverCardTargetProps } from './HoverCardTarget/HoverCardTarget';
 export interface HoverCardProps extends Omit<PopoverProps, 'opened' | 'onChange'> {
-    variant?: string;
     /** Initial opened state */
     initiallyOpened?: boolean;
     /** Called when the dropdown is opened */
     onOpen?: () => void;
     /** Called when the dropdown is closed */
     onClose?: () => void;
-    /** Open delay in ms */
+    /**
+     * Delay in ms before the dropdown opens after mouse enters the target.
+     * Overridden by HoverCard.Group delay if used within a group.
+     * @default 0
+     */
     openDelay?: number;
-    /** Close delay in ms */
+    /**
+     * Delay in ms before the dropdown closes after mouse leaves the target or dropdown.
+     * Overridden by HoverCard.Group delay if used within a group.
+     * @default 150
+     */
     closeDelay?: number;
 }
 export type HoverCardFactory = Factory<{
@@ -24,7 +33,7 @@ export type HoverCardFactory = Factory<{
 export declare function HoverCard(props: HoverCardProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace HoverCard {
     var displayName: string;
-    var Target: import("react").ForwardRefExoticComponent<import(".").HoverCardTargetProps & import("react").RefAttributes<HTMLElement>>;
+    var Target: typeof HoverCardTarget;
     var Dropdown: typeof HoverCardDropdown;
     var Group: typeof HoverCardGroup;
     var extend: (input: ExtendComponent<HoverCardFactory>) => import("../../core/factory/factory").ExtendsRootComponent<{
@@ -33,3 +42,14 @@ export declare namespace HoverCard {
         vars: PopoverCssVariables;
     }>;
 }
+export declare namespace HoverCard {
+    type Props = HoverCardProps;
+    type DropdownProps = HoverCardDropdownProps;
+    type TargetProps = HoverCardTargetProps;
+    type GroupProps = HoverCardGroupProps;
+    type ContextValue = HoverCardContextValue;
+    namespace Group {
+        type Props = HoverCardGroupProps;
+        type ContextValue = HoverCardGroupContextValue;
+    }
+}

package/lib/components/HoverCard/HoverCardGroup/HoverCardGroup.d.ts

@@ -1,4 +1,8 @@
 import { ExtendComponent, Factory, MantineThemeComponent } from '../../../core';
+export interface HoverCardGroupContextValue {
+    withinGroup: boolean;
+}
+export declare const HoverCardGroupContext: import("react").Context<HoverCardGroupContextValue>;
 export interface HoverCardGroupProps {
     /** `HoverCard` components */
     children: React.ReactNode;

package/lib/components/HoverCard/HoverCardTarget/HoverCardTarget.d.ts

@@ -1,6 +1,14 @@
 import { PopoverTargetProps } from '../../Popover';
 export interface HoverCardTargetProps extends PopoverTargetProps {
-    /** Key of the prop used to pass event listeners, by default event listeners are passed directly to component */
+    /**
+     * Name of the prop to wrap event listeners in.
+     * Use when the target component expects event listeners in a nested object.
+     * For example, some components expect `componentProps={{ onMouseEnter, onMouseLeave }}`.
+     * @default undefined (event listeners passed directly to component)
+     */
     eventPropsWrapperName?: string;
 }
-export declare const HoverCardTarget: import("react").ForwardRefExoticComponent<HoverCardTargetProps & import("react").RefAttributes<HTMLElement>>;
+export declare function HoverCardTarget(props: HoverCardTargetProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace HoverCardTarget {
+    var displayName: string;
+}

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

@@ -1,8 +1,10 @@
 export { HoverCard } from './HoverCard';
 export { HoverCardDropdown } from './HoverCardDropdown/HoverCardDropdown';
 export { HoverCardTarget } from './HoverCardTarget/HoverCardTarget';
-export { HoverCardGroup } from './HoverCardGroup/HoverCardGroup';
+export { HoverCardGroup, HoverCardGroupContext } from './HoverCardGroup/HoverCardGroup';
+export { useHoverCardContext } from './HoverCard.context';
+export type { HoverCardContextValue } from './HoverCard.context';
 export type { HoverCardProps } from './HoverCard';
 export type { HoverCardDropdownProps } from './HoverCardDropdown/HoverCardDropdown';
 export type { HoverCardTargetProps } from './HoverCardTarget/HoverCardTarget';
-export type { HoverCardGroupProps } from './HoverCardGroup/HoverCardGroup';
+export type { HoverCardGroupProps, HoverCardGroupContextValue, } from './HoverCardGroup/HoverCardGroup';

package/lib/components/Image/Image.d.ts

@@ -4,9 +4,9 @@ export type ImageCssVariables = {
     root: '--image-radius' | '--image-object-fit';
 };
 export interface ImageProps extends BoxProps, StylesApiProps<ImageFactory> {
-    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default `0` */
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default 0 */
     radius?: MantineRadius;
-    /** Controls `object-fit` style @default `'cover'` */
+    /** Controls `object-fit` style @default 'cover' */
     fit?: React.CSSProperties['objectFit'];
     /** Image url used as a fallback if the image cannot be loaded */
     fallbackSrc?: string;
@@ -24,7 +24,7 @@ export type ImageFactory = PolymorphicFactory<{
 }>;
 export declare const Image: (<C = "img">(props: import("../..").PolymorphicComponentProps<C, ImageProps>) => React.ReactElement) & Omit<import("react").FunctionComponent<(ImageProps & {
     component?: any;
-} & Omit<Omit<any, "ref">, "component" | keyof ImageProps> & {
+} & Omit<any, "component" | keyof ImageProps> & {
     ref?: any;
     renderRoot?: (props: any) => any;
 }) | (ImageProps & {
@@ -42,7 +42,15 @@ export declare const Image: (<C = "img">(props: import("../..").PolymorphicCompo
     defaultComponent: "img";
     stylesNames: ImageStylesNames;
     vars: ImageCssVariables;
-}> & import("../../core/factory/polymorphic-factory").PolymorphicComponentWithProps<{
+}> & {
+    varsResolver: import("../..").VarsResolver<{
+        props: ImageProps;
+        defaultRef: HTMLImageElement;
+        defaultComponent: "img";
+        stylesNames: ImageStylesNames;
+        vars: ImageCssVariables;
+    }>;
+} & import("../../core/factory/polymorphic-factory").PolymorphicComponentWithProps<{
     props: ImageProps;
     defaultRef: HTMLImageElement;
     defaultComponent: "img";

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

@@ -1,2 +1,9 @@
+import type { ImageCssVariables, ImageFactory, ImageProps, ImageStylesNames } from './Image';
 export { Image } from './Image';
-export type { ImageCssVariables, ImageFactory, ImageProps, ImageStylesNames } from './Image';
+export type { ImageProps, ImageStylesNames, ImageCssVariables, ImageFactory };
+export declare namespace Image {
+    type Props = ImageProps;
+    type StylesNames = ImageStylesNames;
+    type CssVariables = ImageCssVariables;
+    type Factory = ImageFactory;
+}

package/lib/components/Indicator/Indicator.d.ts

@@ -6,30 +6,37 @@ export type IndicatorCssVariables = {
     root: '--indicator-color' | '--indicator-text-color' | '--indicator-size' | '--indicator-radius' | '--indicator-z-index' | IndicatorPositionVariables;
 };
 export interface IndicatorProps extends BoxProps, StylesApiProps<IndicatorFactory>, ElementProps<'div'> {
-    /** Indicator position relative to the target element @default `'top-end'` */
+    /** Indicator position relative to the target element @default 'top-end' */
     position?: IndicatorPosition;
-    /** Indicator offset relative to the target element, usually used for elements with border-radius */
-    offset?: number;
-    /** Determines whether the indicator container should be an inline element @default `false` */
+    /** Distance in pixels to offset the indicator from its default position, useful for elements with border-radius. Can be a number for uniform offset or an object with `x` and `y` properties for separate horizontal and vertical offsets @default 0 */
+    offset?: number | {
+        x: number;
+        y: number;
+    };
+    /** Changes container display from block to inline-block, use when wrapping elements with fixed width @default false */
     inline?: boolean;
-    /** Indicator width and height @default `10` */
+    /** Indicator width and height @default 10 */
     size?: number | string;
     /** Label displayed inside the indicator, for example, notification count */
     label?: React.ReactNode;
-    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default `100` */
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default 100 */
     radius?: MantineRadius;
-    /** Key of `theme.colors` or any valid CSS color value @default `theme.primaryColor` */
+    /** Key of `theme.colors` or any valid CSS color value @default theme.primaryColor */
     color?: MantineColor;
     /** Adds border to the root element */
     withBorder?: boolean;
-    /** If set, the indicator is hidden */
+    /** Hides the indicator when set */
     disabled?: boolean;
-    /** If set, the indicator has processing animation @default `false` */
+    /** If set, the indicator has processing animation @default false */
     processing?: boolean;
-    /** Indicator z-index @default `200` */
+    /** Indicator z-index @default 200 */
     zIndex?: string | number;
-    /** If set, adjusts text color based on background color for `filled` variant */
+    /** If set, adjusts text color based on background color */
     autoContrast?: boolean;
+    /** Maximum value to display. If label is a number greater than this value, it will be displayed as `{maxValue}+` */
+    maxValue?: number;
+    /** Determines whether indicator with label `0` should be displayed @default true */
+    showZero?: boolean;
 }
 export type IndicatorFactory = Factory<{
     props: IndicatorProps;

package/lib/components/Indicator/get-position-variables/get-position-variables.d.ts

@@ -1,3 +1,6 @@
 import type { IndicatorPositionVariables } from '../Indicator';
 import type { IndicatorPosition } from '../Indicator.types';
-export declare function getPositionVariables(_position?: IndicatorPosition, offset?: number): Record<IndicatorPositionVariables, string | undefined>;
+export declare function getPositionVariables(_position?: IndicatorPosition, offset?: number | {
+    x: number;
+    y: number;
+}): Record<IndicatorPositionVariables, string | undefined>;

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

@@ -1,2 +1,9 @@
+import type { IndicatorCssVariables, IndicatorFactory, IndicatorPositionVariables, IndicatorProps, IndicatorStylesNames } from './Indicator';
 export { Indicator } from './Indicator';
-export type { IndicatorCssVariables, IndicatorFactory, IndicatorPositionVariables, IndicatorProps, IndicatorStylesNames, } from './Indicator';
+export type { IndicatorProps, IndicatorStylesNames, IndicatorCssVariables, IndicatorFactory, IndicatorPositionVariables, };
+export declare namespace Indicator {
+    type Props = IndicatorProps;
+    type StylesNames = IndicatorStylesNames;
+    type CssVariables = IndicatorCssVariables;
+    type Factory = IndicatorFactory;
+}

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

@@ -1,9 +1,6 @@
 import { MantineSize } from '../../core';
-interface InputContext {
+interface InputContextValue {
     size: MantineSize | (string & {});
 }
-export declare const InputContext: ({ children, value }: {
-    value: InputContext;
-    children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element, useInputContext: () => InputContext | null;
+export declare const InputContext: import("react").Context<InputContextValue>;
 export {};