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

package/lib/components/Slider/Thumb/Thumb.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { MantineTransition } from '../../Transition';
+import { TransitionOverride } from '../../Transition';
 export interface ThumbProps {
     max: number;
     min: number;
@@ -9,9 +9,7 @@ export interface ThumbProps {
     label: React.ReactNode;
     onKeyDownCapture?(event: React.KeyboardEvent<HTMLDivElement>): void;
     onMouseDown?(event: React.MouseEvent<HTMLDivElement> | React.TouchEvent<HTMLDivElement>): void;
-    labelTransition: MantineTransition | undefined;
-    labelTransitionDuration: number | undefined;
-    labelTransitionTimingFunction: string | undefined;
+    labelTransitionProps: TransitionOverride | undefined;
     labelAlwaysOn: boolean | undefined;
     thumbLabel: string | undefined;
     onFocus?(): void;

package/lib/components/Slider/Track/Track.d.ts

@@ -15,7 +15,7 @@ export interface TrackProps {
     inverted: boolean | undefined;
     containerProps?: React.PropsWithRef<React.ComponentProps<'div'>>;
 }
-export declare function Track({ filled, children, offset, disabled, marksOffset, inverted, containerProps, ...others }: TrackProps): JSX.Element;
+export declare function Track({ filled, children, offset, disabled, marksOffset, inverted, containerProps, ...others }: TrackProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Track {
     var displayName: string;
 }

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

@@ -2,4 +2,4 @@ export { Slider } from './Slider/Slider';
 export { RangeSlider } from './RangeSlider/RangeSlider';
 export type { SliderFactory, SliderProps } from './Slider/Slider';
 export type { RangeSliderFactory, RangeSliderProps, RangeSliderValue, } from './RangeSlider/RangeSlider';
-export type { SliderStylesNames, SliderCssVariables, SliderVariant } from './Slider.context';
+export type { SliderStylesNames, SliderCssVariables } from './Slider.context';

package/lib/components/Slider/utils/get-floating-value/get-gloating-value.d.ts

@@ -0,0 +1 @@
+export declare function getFloatingValue(value: number, precision: number): number;

package/lib/components/Slider/utils/get-precision/get-precision.d.ts

@@ -0,0 +1 @@
+export declare function getPrecision(step: number): number;

package/lib/components/Space/Space.d.ts

@@ -0,0 +1,11 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../core';
+export interface SpaceProps extends BoxProps, StylesApiProps<SpaceFactory>, ElementProps<'div'> {
+}
+export type SpaceFactory = Factory<{
+    props: SpaceProps;
+    ref: HTMLDivElement;
+}>;
+export declare const Space: import("../../core").MantineComponent<{
+    props: SpaceProps;
+    ref: HTMLDivElement;
+}>;

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

@@ -0,0 +1,2 @@
+export { Space } from './Space';
+export type { SpaceFactory, SpaceProps } from './Space';

package/lib/components/Stack/Stack.d.ts

@@ -1,12 +1,11 @@
 import React from 'react';
 import { BoxProps, StylesApiProps, ElementProps, MantineSpacing, Factory } from '../../core';
 export type StackStylesNames = 'root';
-export type StackVariant = string;
 export type StackCssVariables = {
     root: '--stack-gap' | '--stack-align' | '--stack-justify';
 };
 export interface StackProps extends BoxProps, StylesApiProps<StackFactory>, ElementProps<'div'> {
-    /** Key of `theme.spacing` or any valid CSS value to set `gap` property, numbers are converted to rem (1rem = 16px), `'md'` by default */
+    /** Key of `theme.spacing` or any valid CSS value to set `gap` property, numbers are converted to rem, `'md'` by default */
     gap?: MantineSpacing | (string & {}) | number;
     /** Controls `align-items` CSS property, `'stretch'` by default */
     align?: React.CSSProperties['alignItems'];
@@ -18,12 +17,10 @@ export type StackFactory = Factory<{
     ref: HTMLDivElement;
     stylesNames: StackStylesNames;
     vars: StackCssVariables;
-    variant: StackVariant;
 }>;
 export declare const Stack: import("../../core").MantineComponent<{
     props: StackProps;
     ref: HTMLDivElement;
     stylesNames: StackStylesNames;
     vars: StackCssVariables;
-    variant: StackVariant;
 }>;

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

@@ -1,2 +1,2 @@
 export { Stack } from './Stack';
-export type { StackCssVariables, StackFactory, StackStylesNames, StackProps, StackVariant, } from './Stack';
+export type { StackCssVariables, StackFactory, StackStylesNames, StackProps } from './Stack';

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import type { StepperFactory } from './Stepper';
+interface StepperContextValue {
+    getStyles: GetStylesApi<StepperFactory>;
+    orientation: 'horizontal' | 'vertical' | undefined;
+    iconPosition: 'left' | 'right' | undefined;
+}
+export declare const StepperProvider: ({ children, value }: {
+    value: StepperContextValue;
+    children: import("react").ReactNode;
+}) => import("react/jsx-runtime").JSX.Element, useStepperContext: () => StepperContextValue;
+export {};

package/lib/components/Stepper/Stepper.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineColor, MantineSpacing, MantineSize, MantineRadius } from '../../core';
+import { StepperStep } from './StepperStep/StepperStep';
+import { StepperCompleted } from './StepperCompleted/StepperCompleted';
+export type StepFragmentComponent = React.FC<{
+    step: number;
+}>;
+export type StepperStylesNames = 'root' | 'separator' | 'steps' | 'content' | 'step' | 'stepLoader' | 'verticalSeparator' | 'stepWrapper' | 'stepIcon' | 'stepCompletedIcon' | 'stepBody' | 'stepLabel' | 'stepDescription';
+export type StepperCssVariables = {
+    root: '--stepper-color' | '--stepper-icon-size' | '--stepper-content-padding' | '--stepper-radius' | '--stepper-fz' | '--stepper-spacing';
+};
+export interface StepperProps extends BoxProps, StylesApiProps<StepperFactory>, ElementProps<'div'> {
+    /** <Stepper.Step /> components */
+    children: React.ReactNode;
+    /** Called when step is clicked */
+    onStepClick?(stepIndex: number): void;
+    /** Index of the active step */
+    active: number;
+    /** Step icon, default value is step index + 1 */
+    icon?: React.ReactNode | StepFragmentComponent;
+    /** Step icon displayed when step is completed, check icon by default */
+    completedIcon?: React.ReactNode | StepFragmentComponent;
+    /** Step icon displayed when step is in progress, default value is step index + 1 */
+    progressIcon?: React.ReactNode | StepFragmentComponent;
+    /** Key of `theme.colors` or any valid CSS color, controls colors of active and progress steps, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Controls size of the step icon, by default icon size is inferred from `size` prop */
+    iconSize?: number | string;
+    /** Key of `theme.spacing` or any valid CSS value to set `padding-top` of the content */
+    contentPadding?: MantineSpacing | (string & {}) | number;
+    /** Stepper orientation, `'horizontal'` by default */
+    orientation?: 'vertical' | 'horizontal';
+    /** Icon position relative to the step body, `'left'` by default */
+    iconPosition?: 'right' | 'left';
+    /** Controls size of various Stepper elements */
+    size?: MantineSize;
+    /** Key of `theme.radius` or any valid CSS value to set steps border-radius, `"xl"` by default */
+    radius?: MantineRadius | (string & {}) | number;
+    /** Determines whether next steps can be selected, `true` by default **/
+    allowNextStepsSelect?: boolean;
+    /** Determines whether steps should wrap to the next line if no space is available, `true` by default */
+    wrap?: boolean;
+}
+export type StepperFactory = Factory<{
+    props: StepperProps;
+    ref: HTMLDivElement;
+    stylesNames: StepperStylesNames;
+    vars: StepperCssVariables;
+    staticComponents: {
+        Step: typeof StepperStep;
+        Completed: typeof StepperCompleted;
+    };
+}>;
+export declare const Stepper: import("../../core").MantineComponent<{
+    props: StepperProps;
+    ref: HTMLDivElement;
+    stylesNames: StepperStylesNames;
+    vars: StepperCssVariables;
+    staticComponents: {
+        Step: typeof StepperStep;
+        Completed: typeof StepperCompleted;
+    };
+}>;

package/lib/components/Stepper/StepperCompleted/StepperCompleted.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface StepperCompletedProps {
+    /** Label content */
+    children: React.ReactNode;
+}
+export declare const StepperCompleted: React.FC<StepperCompletedProps>;

package/lib/components/Stepper/StepperStep/StepperStep.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineColor } from '../../../core';
+import type { StepFragmentComponent } from '../Stepper';
+export type StepperStepStylesNames = 'step' | 'stepLoader' | 'verticalSeparator' | 'stepWrapper' | 'stepIcon' | 'stepCompletedIcon' | 'stepBody' | 'stepLabel' | 'stepDescription';
+export interface StepperStepProps extends BoxProps, StylesApiProps<StepperStepFactory>, ElementProps<'button'> {
+    /** Step index, controlled by Stepper component **/
+    step?: number;
+    /** Step state, controlled by Stepper component */
+    state?: 'stepInactive' | 'stepProgress' | 'stepCompleted';
+    /** Key of `theme.colors`, by default controlled by Stepper component */
+    color?: MantineColor;
+    /** Determines whether the icon should be displayed */
+    withIcon?: boolean;
+    /** Step icon, defaults to step index + 1 when rendered within Stepper */
+    icon?: React.ReactNode | StepFragmentComponent;
+    /** Step icon displayed when step is completed */
+    completedIcon?: React.ReactNode | StepFragmentComponent;
+    /** Step icon displayed when step is in progress */
+    progressIcon?: React.ReactNode | StepFragmentComponent;
+    /** Step label, render after icon */
+    label?: React.ReactNode | StepFragmentComponent;
+    /** Step description */
+    description?: React.ReactNode | StepFragmentComponent;
+    /** Icon wrapper size */
+    iconSize?: number;
+    /** Icon position relative to step body, controlled by Stepper component */
+    iconPosition?: 'right' | 'left';
+    /** Indicates loading state of the step */
+    loading?: boolean;
+    /** Set to false to disable clicks on step */
+    allowStepClick?: boolean;
+    /** Should step selection be allowed */
+    allowStepSelect?: boolean;
+    /** Static selector base */
+    __staticSelector?: string;
+    /** Component orientation */
+    orientation?: 'vertical' | 'horizontal';
+}
+export type StepperStepFactory = Factory<{
+    props: StepperStepProps;
+    ref: HTMLButtonElement;
+    stylesNames: StepperStepStylesNames;
+    compound: true;
+}>;
+export declare const StepperStep: import("../../../core").MantineComponent<{
+    props: StepperStepProps;
+    ref: HTMLButtonElement;
+    stylesNames: StepperStepStylesNames;
+    compound: true;
+}>;

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

@@ -0,0 +1,6 @@
+export { Stepper } from './Stepper';
+export { StepperStep } from './StepperStep/StepperStep';
+export { StepperCompleted } from './StepperCompleted/StepperCompleted';
+export type { StepFragmentComponent, StepperCssVariables, StepperFactory, StepperProps, StepperStylesNames, } from './Stepper';
+export type { StepperStepProps } from './StepperStep/StepperStep';
+export type { StepperCompletedProps } from './StepperCompleted/StepperCompleted';

package/lib/components/Switch/Switch.d.ts

@@ -3,12 +3,11 @@ import { BoxProps, StylesApiProps, ElementProps, MantineColor, MantineSize, Mant
 import { InlineInputStylesNames } from '../InlineInput';
 import { SwitchGroup } from './SwitchGroup/SwitchGroup';
 export type SwitchStylesNames = 'root' | 'track' | 'trackLabel' | 'thumb' | 'input' | InlineInputStylesNames;
-export type SwitchVariant = string;
 export type SwitchCssVariables = {
     root: '--switch-radius' | '--switch-height' | '--switch-width' | '--switch-thumb-size' | '--switch-label-font-size' | '--switch-track-label-padding' | '--switch-color';
 };
 export interface SwitchProps extends BoxProps, StylesApiProps<SwitchFactory>, ElementProps<'input', 'size'> {
-    /** Id is used to bind input and label, if not passed unique id will be generated for each input */
+    /** Id used to bind input and label, if not passed, unique id will be generated instead */
     id?: string;
     /** Switch label */
     label?: React.ReactNode;
@@ -22,15 +21,15 @@ export interface SwitchProps extends BoxProps, StylesApiProps<SwitchFactory>, El
     size?: MantineSize | (string & {});
     /** Key of `theme.radius` or any valid CSS value to set `border-radius,` "xl" by default */
     radius?: MantineRadius | (string & {}) | number;
-    /** Props spread to wrapper element */
-    wrapperProps?: Record<string, any>;
+    /** Props passed down to the wrapper element */
+    wrapperProps?: React.ComponentPropsWithoutRef<'div'>;
     /** Icon inside the thumb of switch */
     thumbIcon?: React.ReactNode;
     /** Position of the label relative to the input, `'right'` by default */
     labelPosition?: 'left' | 'right';
-    /** Description displayed below label */
+    /** Description displayed below the label */
     description?: React.ReactNode;
-    /** Error displayed below label */
+    /** Error displayed below the label */
     error?: React.ReactNode;
 }
 export type SwitchFactory = Factory<{
@@ -38,7 +37,6 @@ export type SwitchFactory = Factory<{
     ref: HTMLInputElement;
     stylesNames: SwitchStylesNames;
     vars: SwitchCssVariables;
-    variant: SwitchVariant;
     staticComponents: {
         Group: typeof SwitchGroup;
     };
@@ -48,7 +46,6 @@ export declare const Switch: import("../../core").MantineComponent<{
     ref: HTMLInputElement;
     stylesNames: SwitchStylesNames;
     vars: SwitchCssVariables;
-    variant: SwitchVariant;
     staticComponents: {
         Group: typeof SwitchGroup;
     };

package/lib/components/Switch/SwitchGroup/SwitchGroup.d.ts

@@ -2,9 +2,8 @@ import React from 'react';
 import { MantineSize, Factory } from '../../../core';
 import { InputWrapperStylesNames, InputWrapperProps } from '../../Input';
 export type SwitchGroupStylesNames = InputWrapperStylesNames;
-export type SwitchGroupVariant = string;
 export interface SwitchGroupProps extends Omit<InputWrapperProps, 'onChange'> {
-    /** <Switch /> components */
+    /** `Switch` components */
     children: React.ReactNode;
     /** Controlled component value */
     value?: string[];
@@ -12,9 +11,9 @@ export interface SwitchGroupProps extends Omit<InputWrapperProps, 'onChange'> {
     defaultValue?: string[];
     /** Called when value changes */
     onChange?(value: string[]): void;
-    /** Props spread to `Input.Wrapper` */
-    wrapperProps?: Record<string, any>;
-    /** Controls size of `Input.Wrapper`, `'sm'` by default */
+    /** Props passed down to the `Input.Wrapper` */
+    wrapperProps?: React.ComponentPropsWithoutRef<'div'>;
+    /** Controls size of the `Input.Wrapper`, `'sm'` by default */
     size?: MantineSize | (string & {});
 }
 export type SwitchGroupFactory = Factory<{

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

@@ -1,3 +1,4 @@
 export { Switch } from './Switch';
-export type { SwitchCssVariables, SwitchFactory, SwitchProps, SwitchStylesNames, SwitchVariant, } from './Switch';
-export type { SwitchGroupFactory, SwitchGroupProps, SwitchGroupStylesNames, SwitchGroupVariant, } from './SwitchGroup/SwitchGroup';
+export { SwitchGroup } from './SwitchGroup/SwitchGroup';
+export type { SwitchCssVariables, SwitchFactory, SwitchProps, SwitchStylesNames } from './Switch';
+export type { SwitchGroupFactory, SwitchGroupProps, SwitchGroupStylesNames, } from './SwitchGroup/SwitchGroup';

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

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { GetStylesApi } from '../../core';
 import type { TableFactory } from './Table';
 export interface TableContextValue {
@@ -11,4 +12,4 @@ export interface TableContextValue {
 export declare const TableProvider: ({ children, value }: {
     value: TableContextValue;
     children: import("react").ReactNode;
-}) => JSX.Element, useTableContext: () => TableContextValue;
+}) => import("react/jsx-runtime").JSX.Element, useTableContext: () => TableContextValue;

package/lib/components/Table/Table.d.ts

@@ -1,17 +1,17 @@
 import React from 'react';
 import { BoxProps, StylesApiProps, ElementProps, MantineColor, MantineSpacing, Factory } from '../../core';
 import { TableCaption, TableTbody, TableTd, TableTfoot, TableTh, TableTr, TableThead } from './Table.components';
+import { TableScrollContainer } from './TableScrollContainer';
 export type TableStylesNames = 'table' | 'thead' | 'tbody' | 'tfoot' | 'tr' | 'th' | 'td' | 'caption';
-export type TableVariant = string;
 export type TableCssVariables = {
     table: '--table-layout' | '--table-border-color' | '--table-caption-side' | '--table-horizontal-spacing' | '--table-vertical-spacing' | '--table-striped-color' | '--table-highlight-on-hover-color';
 };
 export interface TableProps extends BoxProps, StylesApiProps<TableFactory>, ElementProps<'table'> {
-    /** Value of `table-layout` style, `unset` by default */
+    /** Value of `table-layout` style, `auto` by default */
     layout?: React.CSSProperties['tableLayout'];
     /** Determines on which side `Table.Caption` is displayed, `bottom` by default */
     captionSide?: 'top' | 'bottom';
-    /** Color of border, key of `theme.colors` or any valid CSS color, by default inferred from current color scheme */
+    /** Color of table borders, key of `theme.colors` or any valid CSS color */
     borderColor?: MantineColor;
     /** Determines whether the table should have outer border, `false` by default */
     withTableBorder?: boolean;
@@ -19,17 +19,17 @@ export interface TableProps extends BoxProps, StylesApiProps<TableFactory>, Elem
     withColumnBorders?: boolean;
     /** Determines whether the table should have borders between rows, `true` by default */
     withRowBorders?: boolean;
-    /** Horizontal cells spacing, key of `theme.spacing` or any valid CSS value for padding, numbers are converted to rem (1rem = 16px), default value is `xs` */
+    /** Horizontal cells spacing, key of `theme.spacing` or any valid CSS value for padding, numbers are converted to rem, default value is `xs` */
     horizontalSpacing?: MantineSpacing | number | (string & {});
-    /** Vertical cells spacing, key of `theme.spacing` or any valid CSS value for padding, numbers are converted to rem (1rem = 16px), default value is `xs` */
+    /** Vertical cells spacing, key of `theme.spacing` or any valid CSS value for padding, numbers are converted to rem, default value is `xs` */
     verticalSpacing?: MantineSpacing | number | (string & {});
     /** Determines whether every odd/even row background should be changed to `strippedColor`, if set to `true`, then `odd` value will be used, `false` by default  */
     striped?: boolean | 'odd' | 'even';
-    /** Background color of striped rows, key of `theme.colors` or any valid CSS color, by default color is inferred from current color scheme */
+    /** Background color of striped rows, key of `theme.colors` or any valid CSS color */
     stripedColor?: MantineColor;
     /** Determines whether table rows background should change to `highlightOnHoverColor` when hovered, `false` by default */
     highlightOnHover?: boolean;
-    /** Background color of table rows when hovered, key of `theme.colors` or any valid CSS color, by default color is inferred from current color scheme */
+    /** Background color of table rows when hovered, key of `theme.colors` or any valid CSS color */
     highlightOnHoverColor?: MantineColor;
 }
 export type TableFactory = Factory<{
@@ -45,6 +45,7 @@ export type TableFactory = Factory<{
         Th: typeof TableTh;
         Tr: typeof TableTr;
         Caption: typeof TableCaption;
+        ScrollContainer: typeof TableScrollContainer;
     };
 }>;
 export declare const Table: import("../../core").MantineComponent<{
@@ -60,5 +61,6 @@ export declare const Table: import("../../core").MantineComponent<{
         Th: typeof TableTh;
         Tr: typeof TableTr;
         Caption: typeof TableCaption;
+        ScrollContainer: typeof TableScrollContainer;
     };
 }>;

package/lib/components/Table/TableScrollContainer.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../core';
+export type TableScrollContainerStylesNames = 'scrollContainer' | 'scrollContainerInner';
+export type TableScrollContainerCssVariables = {
+    scrollContainer: '--table-min-width' | '--table-overflow';
+};
+export interface TableScrollContainerProps extends BoxProps, StylesApiProps<TableScrollContainerFactory>, ElementProps<'div'> {
+    /** `min-width` of the `Table` at which it should become scrollable */
+    minWidth: React.CSSProperties['minWidth'];
+    /** Type of the scroll container, `native` to use native scrollbars, `scrollarea` to use `ScrollArea` component, `scrollarea` by default */
+    type?: 'native' | 'scrollarea';
+}
+export type TableScrollContainerFactory = Factory<{
+    props: TableScrollContainerProps;
+    ref: HTMLDivElement;
+    stylesNames: TableScrollContainerStylesNames;
+    vars: TableScrollContainerCssVariables;
+}>;
+export declare const TableScrollContainer: import("../../core").MantineComponent<{
+    props: TableScrollContainerProps;
+    ref: HTMLDivElement;
+    stylesNames: TableScrollContainerStylesNames;
+    vars: TableScrollContainerCssVariables;
+}>;

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

@@ -1,3 +1,5 @@
 export { Table } from './Table';
-export type { TableProps, TableStylesNames, TableCssVariables, TableFactory, TableVariant, } from './Table';
+export { TableCaption, TableTbody, TableTd, TableTfoot, TableTr, TableTh, TableThead, } from './Table.components';
+export { TableScrollContainer } from './TableScrollContainer';
+export type { TableProps, TableStylesNames, TableCssVariables, TableFactory } from './Table';
 export type { TableTbodyProps, TableTdProps, TableThProps, TableTrProps, TableCaptionProps, TableTfootProps, TableTheadProps, } from './Table.components';

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

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { GetStylesApi } from '../../core';
 import type { TabsFactory } from './Tabs';
 export interface TabsContextValue {
@@ -22,4 +23,4 @@ export interface TabsContextValue {
 export declare const TabsProvider: ({ children, value }: {
     value: TabsContextValue;
     children: import("react").ReactNode;
-}) => JSX.Element, useTabsContext: () => TabsContextValue;
+}) => import("react/jsx-runtime").JSX.Element, useTabsContext: () => TabsContextValue;

package/lib/components/Tabs/Tabs.d.ts

@@ -13,29 +13,29 @@ export interface TabsProps extends BoxProps, StylesApiProps<TabsFactory>, Elemen
     defaultValue?: string | null;
     /** Value for controlled component */
     value?: string | null;
-    /** Called when tab changes */
+    /** Called when value changes */
     onChange?(value: string | null): void;
-    /** Tabs orientation, vertical or horizontal */
+    /** Tabs orientation, `'horizontal'` by default */
     orientation?: 'vertical' | 'horizontal';
-    /** Tabs.List placement relative to Tabs.Panel, applicable only for orientation="vertical", left by default */
+    /** `Tabs.List` placement relative to `Tabs.Panel`, applicable only when `orientation="vertical"`, `'left'` by default */
     placement?: 'left' | 'right';
-    /** Base id, used to generate ids that connect labels with controls, generated randomly by default */
+    /** Base id, used to generate ids to connect labels with controls, generated randomly by default */
     id?: string;
-    /** Determines whether arrow key presses should loop though items (first to last and last to first) */
+    /** Determines whether arrow key presses should loop though items (first to last and last to first), `true` by default */
     loop?: boolean;
-    /** Determines whether tab should be activated with arrow key press, defaults to true */
+    /** Determines whether tab should be activated with arrow key press, `true` by default */
     activateTabWithKeyboard?: boolean;
-    /** Determines whether tab can be deactivated, defaults to false */
+    /** Determines whether tab can be deactivated, `false` by default */
     allowTabDeactivation?: boolean;
     /** Tabs content */
     children: React.ReactNode;
-    /** Changes colors of `<Tabs.Tab />` components when variant is `pills` and `default`, does nothing for other variants */
+    /** Changes colors of `Tabs.Tab` components when variant is `pills` or `default`, does nothing for other variants */
     color?: MantineColor;
     /** Key of `theme.radius` or any valid CSS value to set `border-radius`, `theme.defaultRadius` by default */
     radius?: MantineRadius | number | (string & {});
-    /** Determines whether tabs should have inverted styles */
+    /** Determines whether tabs should have inverted styles, `false` by default */
     inverted?: boolean;
-    /** If set to false, Tabs.Panel content will not stay mounted when tab is not active */
+    /** If set to `false`, `Tabs.Panel` content will be unmounted when the associated tab is not active, `true` by default */
     keepMounted?: boolean;
 }
 export type TabsFactory = Factory<{

package/lib/components/Tabs/TabsList/TabsList.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 import { BoxProps, ElementProps, StylesApiProps, Factory } from '../../../core';
 export type TabsListStylesNames = 'list';
 export interface TabsListProps extends BoxProps, StylesApiProps<TabsListFactory>, ElementProps<'div'> {
-    /** <Tabs.Tab /> components */
+    /** `Tabs.Tab` components */
     children: React.ReactNode;
-    /** Determines whether tabs should take the whole space, `false` by default */
+    /** Determines whether tabs should take all available space, `false` by default */
     grow?: boolean;
     /** Tabs alignment, `flex-start` by default */
     justify?: React.CSSProperties['justifyContent'];

package/lib/components/Tabs/TabsTab/TabsTab.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import { ElementProps, MantineColor, StylesApiProps, Factory } from '../../../core';
 import { UnstyledButtonProps } from '../../UnstyledButton';
-export type TabsTabStylesNames = 'tab' | 'tabRightSection' | 'tabLeftSection' | 'tabLabel';
+export type TabsTabStylesNames = 'tab' | 'tabSection' | 'tabLabel';
 export interface TabsTabProps extends Omit<UnstyledButtonProps, 'classNames' | 'styles' | 'vars'>, StylesApiProps<TabsTabFactory>, ElementProps<'button'> {
-    /** Value that is used to connect Tab with associated panel */
+    /** Value of associated panel */
     value: string;
     /** Tab label */
     children?: React.ReactNode;
@@ -11,7 +11,7 @@ export interface TabsTabProps extends Omit<UnstyledButtonProps, 'classNames' | '
     rightSection?: React.ReactNode;
     /** Content displayed on the left side of the label, for example, icon */
     leftSection?: React.ReactNode;
-    /** Key of theme.colors, controls control color based on variant */
+    /** Key of `theme.colors` or any valid CSS color, controls control color based on `variant` */
     color?: MantineColor;
 }
 export type TabsTabFactory = Factory<{

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

@@ -1,4 +1,7 @@
 export { Tabs } from './Tabs';
+export { TabsList } from './TabsList/TabsList';
+export { TabsTab } from './TabsTab/TabsTab';
+export { TabsPanel } from './TabsPanel/TabsPanel';
 export type { TabsProps, TabsCssVariables, TabsFactory, TabsStylesNames, TabsVariant, } from './Tabs';
 export type { TabsTabProps, TabsTabStylesNames } from './TabsTab/TabsTab';
 export type { TabsPanelProps, TabsPanelStylesNames } from './TabsPanel/TabsPanel';

package/lib/components/TagsInput/TagsInput.d.ts

@@ -0,0 +1,36 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../core';
+import { ComboboxLikeProps, ComboboxLikeStylesNames } from '../Combobox';
+import { __BaseInputProps, __InputStylesNames } from '../Input';
+export type TagsInputStylesNames = __InputStylesNames | ComboboxLikeStylesNames | 'pill' | 'pillsList' | 'inputField';
+export interface TagsInputProps extends BoxProps, __BaseInputProps, ComboboxLikeProps, StylesApiProps<TagsInputFactory>, ElementProps<'input', 'size' | 'value' | 'defaultValue' | 'onChange'> {
+    /** Controlled component value */
+    value?: string[];
+    /** Default value for uncontrolled component */
+    defaultValue?: string[];
+    /** Called whe value changes */
+    onChange?(value: string[]): void;
+    /** Controlled search value */
+    searchValue?: string;
+    /** Default search value */
+    defaultSearchValue?: string;
+    /** Called when search changes */
+    onSearchChange?(value: string): void;
+    /** Maximum number of tags, `Infinity` by default */
+    maxTags?: number;
+    /** Determines whether duplicate tags are allowed, `false` by default */
+    allowDuplicates?: boolean;
+    /** Called when user tries to submit a duplicated tag */
+    onDuplicate?(value: string): void;
+    /** Characters that should trigger tags split, `[',']` by default */
+    splitChars?: string[];
+}
+export type TagsInputFactory = Factory<{
+    props: TagsInputProps;
+    ref: HTMLInputElement;
+    stylesNames: TagsInputStylesNames;
+}>;
+export declare const TagsInput: import("../../core").MantineComponent<{
+    props: TagsInputProps;
+    ref: HTMLInputElement;
+    stylesNames: TagsInputStylesNames;
+}>;

package/lib/components/TagsInput/filter-picked-tags.d.ts

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

package/lib/components/TagsInput/get-splitted-tags.d.ts

@@ -0,0 +1,9 @@
+interface GetSplittedTagsInput {
+    splitChars: string[] | undefined;
+    allowDuplicates: boolean | undefined;
+    maxTags: number | undefined;
+    value: string;
+    currentTags: string[];
+}
+export declare function getSplittedTags({ splitChars, allowDuplicates, maxTags, value, currentTags, }: GetSplittedTagsInput): string[];
+export {};

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

@@ -0,0 +1,2 @@
+export { TagsInput } from './TagsInput';
+export type { TagsInputProps, TagsInputStylesNames, TagsInputFactory } from './TagsInput';

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { BoxProps, StylesApiProps, MantineGradient, BoxMod, PolymorphicFactory, MantineSize } from '../../core';
+import { BoxProps, StylesApiProps, MantineGradient, BoxMod, PolymorphicFactory, MantineSize, MantineColor } from '../../core';
 type TextTruncate = 'end' | 'start' | boolean;
 export type TextStylesNames = 'root';
 export type TextVariant = 'text' | 'gradient';
@@ -17,12 +17,14 @@ export interface TextProps extends BoxProps, StylesApiProps<TextFactory> {
     truncate?: TextTruncate;
     /** Sets `line-height` to 1 for centering, `false` by default */
     inline?: boolean;
-    /** Determines whether font properties should be inherited from parent, `true` by default */
+    /** Determines whether font properties should be inherited from the parent, `false` by default */
     inherit?: boolean;
-    /** Gradient object, ignored when `variant` is not `gradient`, `theme.defaultGradient` by default */
+    /** Gradient configuration, ignored when `variant` is not `gradient`, `theme.defaultGradient` by default */
     gradient?: MantineGradient;
     /** Shorthand for `component="span"`, `false` by default, default root element is `p` */
     span?: boolean;
+    /** @deprecated Use `c` prop instead */
+    color?: MantineColor;
 }
 export type TextFactory = PolymorphicFactory<{
     props: TextProps;
@@ -45,5 +47,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 {};