@mantine/core 6.0.9 → 7.0.0-alpha.2

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

@@ -0,0 +1,10 @@
+interface GetChangeValue {
+    value: number;
+    containerWidth?: number;
+    min: number;
+    max: number;
+    step: number;
+    precision?: number;
+}
+export declare function getChangeValue({ value, containerWidth, min, max, step, precision, }: GetChangeValue): number;
+export {};

package/lib/components/Slider/utils/get-client-position/get-client-position.d.ts

@@ -0,0 +1 @@
+export declare function getClientPosition(event: any): any;

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

@@ -0,0 +1,7 @@
+interface GetPosition {
+    value: number;
+    min: number;
+    max: number;
+}
+export declare function getPosition({ value, min, max }: GetPosition): number;
+export {};

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

@@ -0,0 +1,29 @@
+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 */
+    gap?: MantineSpacing | (string & {}) | number;
+    /** Controls `align-items` CSS property, `'stretch'` by default */
+    align?: React.CSSProperties['alignItems'];
+    /** Controls `justify-content` CSS property, `'flex-start'` by default */
+    justify?: React.CSSProperties['justifyContent'];
+}
+export type StackFactory = Factory<{
+    props: StackProps;
+    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

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

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

@@ -0,0 +1,55 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, MantineColor, MantineSize, MantineRadius, Factory } from '../../core';
+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?: string;
+    /** Switch label */
+    label?: React.ReactNode;
+    /** Inner label when Switch is in unchecked state */
+    offLabel?: React.ReactNode;
+    /** Inner label when Switch is in checked state */
+    onLabel?: React.ReactNode;
+    /** Key of `theme.colors` or any valid CSS color to set input color in checked state, `theme.primaryColor` by default */
+    color?: MantineColor;
+    /** Controls size of all elements */
+    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>;
+    /** 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?: React.ReactNode;
+    /** Error displayed below label */
+    error?: React.ReactNode;
+}
+export type SwitchFactory = Factory<{
+    props: SwitchProps;
+    ref: HTMLInputElement;
+    stylesNames: SwitchStylesNames;
+    vars: SwitchCssVariables;
+    variant: SwitchVariant;
+    staticComponents: {
+        Group: typeof SwitchGroup;
+    };
+}>;
+export declare const Switch: import("../../core").MantineComponent<{
+    props: SwitchProps;
+    ref: HTMLInputElement;
+    stylesNames: SwitchStylesNames;
+    vars: SwitchCssVariables;
+    variant: SwitchVariant;
+    staticComponents: {
+        Group: typeof SwitchGroup;
+    };
+}>;

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

@@ -0,0 +1,29 @@
+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 */
+    children: React.ReactNode;
+    /** Controlled component value */
+    value?: string[];
+    /** Default value for uncontrolled component */
+    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 */
+    size?: MantineSize | (string & {});
+}
+export type SwitchGroupFactory = Factory<{
+    props: SwitchGroupProps;
+    ref: HTMLDivElement;
+    stylesNames: SwitchGroupStylesNames;
+}>;
+export declare const SwitchGroup: import("../../../core").MantineComponent<{
+    props: SwitchGroupProps;
+    ref: HTMLDivElement;
+    stylesNames: SwitchGroupStylesNames;
+}>;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { MantineSize } from '../../core';
+interface SwitchGroupContextValue {
+    value: string[];
+    onChange(event: React.ChangeEvent<HTMLInputElement>): void;
+    size: MantineSize | (string & {}) | undefined;
+}
+export declare const SwitchGroupProvider: import("react").Provider<SwitchGroupContextValue | null>;
+export declare const useSwitchGroupContext: () => SwitchGroupContextValue | null;
+export {};

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

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

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

@@ -0,0 +1,113 @@
+import { BoxProps, StylesApiProps, ElementProps, FactoryPayload, Factory } from '../../core';
+import type { TableFactory } from './Table';
+export interface TableElementProps<Selector extends string> extends BoxProps, StylesApiProps<Omit<TableFactory, 'stylesNames'> & {
+    stylesNames: Selector;
+}> {
+}
+export interface TableThProps extends TableElementProps<'th'>, ElementProps<'th'> {
+}
+export interface TableTdProps extends TableElementProps<'td'>, ElementProps<'td'> {
+}
+export interface TableTrProps extends TableElementProps<'tr'>, ElementProps<'tr'> {
+}
+export interface TableTheadProps extends TableElementProps<'thead'>, ElementProps<'thead'> {
+}
+export interface TableTbodyProps extends TableElementProps<'tbody'>, ElementProps<'tbody'> {
+}
+export interface TableTfootProps extends TableElementProps<'tfoot'>, ElementProps<'tfoot'> {
+}
+export interface TableCaptionProps extends TableElementProps<'caption'>, ElementProps<'caption'> {
+}
+export type TableThFactory = Factory<{
+    props: TableThProps;
+    ref: HTMLTableCellElement;
+    stylesNames: 'th';
+    compound: true;
+}>;
+export type TableTdFactory = Factory<{
+    props: TableTdProps;
+    ref: HTMLTableCellElement;
+    stylesNames: 'td';
+    compound: true;
+}>;
+export type TableTrFactory = Factory<{
+    props: TableTrProps;
+    ref: HTMLTableRowElement;
+    stylesNames: 'tr';
+    compound: true;
+}>;
+export type TableTheadFactory = Factory<{
+    props: TableTheadProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'thead';
+    compound: true;
+}>;
+export type TableTbodyFactory = Factory<{
+    props: TableTbodyProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'tbody';
+    compound: true;
+}>;
+export type TableTfootFactory = Factory<{
+    props: TableTfootProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'tfoot';
+    compound: true;
+}>;
+export type TableCaptionFactory = Factory<{
+    props: TableCaptionProps;
+    ref: HTMLTableCaptionElement;
+    stylesNames: 'caption';
+    compound: true;
+}>;
+interface TableElementOptions {
+    columnBorder?: true;
+    rowBorder?: true;
+    striped?: true;
+    highlightOnHover?: true;
+    captionSide?: true;
+}
+export declare function tableElement<Factory extends FactoryPayload>(element: 'th' | 'td' | 'tr' | 'thead' | 'tbody' | 'tfoot' | 'caption', options?: TableElementOptions): import("../../core").MantineComponent<Factory>;
+export declare const TableTh: import("../../core").MantineComponent<{
+    props: TableThProps;
+    ref: HTMLTableCellElement;
+    stylesNames: 'th';
+    compound: true;
+}>;
+export declare const TableTd: import("../../core").MantineComponent<{
+    props: TableTdProps;
+    ref: HTMLTableCellElement;
+    stylesNames: 'td';
+    compound: true;
+}>;
+export declare const TableTr: import("../../core").MantineComponent<{
+    props: TableTrProps;
+    ref: HTMLTableRowElement;
+    stylesNames: 'tr';
+    compound: true;
+}>;
+export declare const TableThead: import("../../core").MantineComponent<{
+    props: TableTheadProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'thead';
+    compound: true;
+}>;
+export declare const TableTbody: import("../../core").MantineComponent<{
+    props: TableTbodyProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'tbody';
+    compound: true;
+}>;
+export declare const TableTfoot: import("../../core").MantineComponent<{
+    props: TableTfootProps;
+    ref: HTMLTableSectionElement;
+    stylesNames: 'tfoot';
+    compound: true;
+}>;
+export declare const TableCaption: import("../../core").MantineComponent<{
+    props: TableCaptionProps;
+    ref: HTMLTableCaptionElement;
+    stylesNames: 'caption';
+    compound: true;
+}>;
+export {};

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

@@ -0,0 +1,14 @@
+import { GetStylesApi } from '../../core';
+import type { TableFactory } from './Table';
+export interface TableContextValue {
+    getStyles: GetStylesApi<TableFactory>;
+    striped: 'odd' | 'even' | undefined;
+    highlightOnHover: boolean | undefined;
+    withColumnBorders: boolean | undefined;
+    withRowBorders: boolean | undefined;
+    captionSide: 'top' | 'bottom';
+}
+export declare const TableProvider: ({ children, value }: {
+    value: TableContextValue;
+    children: import("react").ReactNode;
+}) => JSX.Element, useTableContext: () => TableContextValue;

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

@@ -0,0 +1,64 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, MantineColor, MantineSpacing, Factory } from '../../core';
+import { TableCaption, TableTbody, TableTd, TableTfoot, TableTh, TableTr, TableThead } from './Table.components';
+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 */
+    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 */
+    borderColor?: MantineColor;
+    /** Determines whether the table should have outer border, `false` by default */
+    withTableBorder?: boolean;
+    /** Determines whether the table should have borders between columns, `false` by default */
+    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` */
+    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` */
+    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 */
+    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 */
+    highlightOnHoverColor?: MantineColor;
+}
+export type TableFactory = Factory<{
+    props: TableProps;
+    ref: HTMLTableElement;
+    stylesNames: TableStylesNames;
+    vars: TableCssVariables;
+    staticComponents: {
+        Thead: typeof TableThead;
+        Tbody: typeof TableTbody;
+        Tfoot: typeof TableTfoot;
+        Td: typeof TableTd;
+        Th: typeof TableTh;
+        Tr: typeof TableTr;
+        Caption: typeof TableCaption;
+    };
+}>;
+export declare const Table: import("../../core").MantineComponent<{
+    props: TableProps;
+    ref: HTMLTableElement;
+    stylesNames: TableStylesNames;
+    vars: TableCssVariables;
+    staticComponents: {
+        Thead: typeof TableThead;
+        Tbody: typeof TableTbody;
+        Tfoot: typeof TableTfoot;
+        Td: typeof TableTd;
+        Th: typeof TableTh;
+        Tr: typeof TableTr;
+        Caption: typeof TableCaption;
+    };
+}>;

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

@@ -0,0 +1,3 @@
+export { Table } from './Table';
+export type { TableProps, TableStylesNames, TableCssVariables, TableFactory, TableVariant, } from './Table';
+export type { TableTbodyProps, TableTdProps, TableThProps, TableTrProps, TableCaptionProps, TableTfootProps, TableTheadProps, } from './Table.components';

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

@@ -0,0 +1,25 @@
+import { GetStylesApi } from '../../core';
+import type { TabsFactory } from './Tabs';
+export interface TabsContextValue {
+    id: string;
+    value: string | null;
+    orientation: 'horizontal' | 'vertical' | undefined;
+    loop: boolean | undefined;
+    activateTabWithKeyboard: boolean | undefined;
+    allowTabDeactivation: boolean | undefined;
+    onChange(value: string | null): void;
+    getTabId(value: string): string;
+    getPanelId(value: string): string;
+    variant: string | undefined;
+    color: string | undefined;
+    radius: string | number | undefined;
+    inverted: boolean | undefined;
+    keepMounted: boolean | undefined;
+    placement: 'right' | 'left' | undefined;
+    unstyled: boolean | undefined;
+    getStyles: GetStylesApi<TabsFactory>;
+}
+export declare const TabsProvider: ({ children, value }: {
+    value: TabsContextValue;
+    children: import("react").ReactNode;
+}) => JSX.Element, useTabsContext: () => TabsContextValue;

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

@@ -0,0 +1,64 @@
+import React from 'react';
+import { BoxProps, MantineColor, MantineRadius, StylesApiProps, ElementProps, Factory } from '../../core';
+import { TabsList, TabsListStylesNames } from './TabsList/TabsList';
+import { TabsPanel, TabsPanelStylesNames } from './TabsPanel/TabsPanel';
+import { TabsTab, TabsTabStylesNames } from './TabsTab/TabsTab';
+export type TabsStylesNames = 'root' | TabsListStylesNames | TabsPanelStylesNames | TabsTabStylesNames;
+export type TabsVariant = 'default' | 'outline' | 'pills';
+export type TabsCssVariables = {
+    root: '--tabs-color' | '--tabs-radius';
+};
+export interface TabsProps extends BoxProps, StylesApiProps<TabsFactory>, ElementProps<'div', 'defaultValue' | 'value' | 'onChange'> {
+    /** Default value for uncontrolled component */
+    defaultValue?: string | null;
+    /** Value for controlled component */
+    value?: string | null;
+    /** Called when tab changes */
+    onChange?(value: string | null): void;
+    /** Tabs orientation, vertical or horizontal */
+    orientation?: 'vertical' | 'horizontal';
+    /** Tabs.List placement relative to Tabs.Panel, applicable only for orientation="vertical", left by default */
+    placement?: 'left' | 'right';
+    /** Base id, used to generate ids that 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) */
+    loop?: boolean;
+    /** Determines whether tab should be activated with arrow key press, defaults to true */
+    activateTabWithKeyboard?: boolean;
+    /** Determines whether tab can be deactivated, defaults to false */
+    allowTabDeactivation?: boolean;
+    /** Tabs content */
+    children: React.ReactNode;
+    /** Changes colors of `<Tabs.Tab />` components when variant is `pills` and `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 */
+    inverted?: boolean;
+    /** If set to false, Tabs.Panel content will not stay mounted when tab is not active */
+    keepMounted?: boolean;
+}
+export type TabsFactory = Factory<{
+    props: TabsProps;
+    ref: HTMLDivElement;
+    variant: TabsVariant;
+    stylesNames: TabsStylesNames;
+    vars: TabsCssVariables;
+    staticComponents: {
+        Tab: typeof TabsTab;
+        Panel: typeof TabsPanel;
+        List: typeof TabsList;
+    };
+}>;
+export declare const Tabs: import("../../core").MantineComponent<{
+    props: TabsProps;
+    ref: HTMLDivElement;
+    variant: TabsVariant;
+    stylesNames: TabsStylesNames;
+    vars: TabsCssVariables;
+    staticComponents: {
+        Tab: typeof TabsTab;
+        Panel: typeof TabsPanel;
+        List: typeof TabsList;
+    };
+}>;

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

@@ -0,0 +1,23 @@
+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 */
+    children: React.ReactNode;
+    /** Determines whether tabs should take the whole space, `false` by default */
+    grow?: boolean;
+    /** Tabs alignment, `flex-start` by default */
+    justify?: React.CSSProperties['justifyContent'];
+}
+export type TabsListFactory = Factory<{
+    props: TabsListProps;
+    ref: HTMLDivElement;
+    stylesNames: TabsListStylesNames;
+    compound: true;
+}>;
+export declare const TabsList: import("../../../core").MantineComponent<{
+    props: TabsListProps;
+    ref: HTMLDivElement;
+    stylesNames: TabsListStylesNames;
+    compound: true;
+}>;

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { BoxProps, ElementProps, StylesApiProps, Factory } from '../../../core';
+export type TabsPanelStylesNames = 'panel';
+export interface TabsPanelProps extends BoxProps, StylesApiProps<TabsPanelFactory>, ElementProps<'div'> {
+    /** Panel content */
+    children: React.ReactNode;
+    /** Value of associated control */
+    value: string;
+}
+export type TabsPanelFactory = Factory<{
+    props: TabsPanelProps;
+    ref: HTMLDivElement;
+    stylesNames: TabsPanelStylesNames;
+    compound: true;
+}>;
+export declare const TabsPanel: import("../../../core").MantineComponent<{
+    props: TabsPanelProps;
+    ref: HTMLDivElement;
+    stylesNames: TabsPanelStylesNames;
+    compound: true;
+}>;

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import { ElementProps, MantineColor, StylesApiProps, Factory } from '../../../core';
+import { UnstyledButtonProps } from '../../UnstyledButton';
+export type TabsTabStylesNames = 'tab' | 'tabRightSection' | 'tabLeftSection' | '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: string;
+    /** Tab label */
+    children?: React.ReactNode;
+    /** Content displayed on the right side of the label, for example, icon */
+    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 */
+    color?: MantineColor;
+}
+export type TabsTabFactory = Factory<{
+    props: TabsTabProps;
+    ref: HTMLButtonElement;
+    stylesNames: TabsTabStylesNames;
+    compound: true;
+}>;
+export declare const TabsTab: import("../../../core").MantineComponent<{
+    props: TabsTabProps;
+    ref: HTMLButtonElement;
+    stylesNames: TabsTabStylesNames;
+    compound: true;
+}>;

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

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

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

@@ -0,0 +1,49 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, MantineGradient, BoxMod, PolymorphicFactory, MantineSize } from '../../core';
+type TextTruncate = 'end' | 'start' | boolean;
+export type TextStylesNames = 'root';
+export type TextVariant = 'text' | 'gradient';
+export type TextCssVariables = {
+    root: '--text-gradient' | '--text-line-clamp' | '--text-fz' | '--text-lh';
+};
+export interface TextProps extends BoxProps, StylesApiProps<TextFactory> {
+    __staticSelector?: string;
+    mod?: BoxMod;
+    /** Controls `font-size` and `line-height`, `'md'` by default */
+    size?: MantineSize | (string & {});
+    /** Number of lines after which Text will be truncated */
+    lineClamp?: number;
+    /** Side on which Text must be truncated, if `true`, text in truncated from the start */
+    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 */
+    inherit?: boolean;
+    /** Gradient object, 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;
+}
+export type TextFactory = PolymorphicFactory<{
+    props: TextProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLParagraphElement;
+    stylesNames: TextStylesNames;
+    vars: TextCssVariables;
+    variant: TextVariant;
+}>;
+export declare const Text: (<C = "div">(props: import("../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, TextProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(TextProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof TextProps> & {
+    ref?: any;
+}) | (TextProps & {
+    component: React.ElementType<any>;
+})>, never> & import("../../core/factory/factory").ThemeExtend<{
+    props: TextProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLParagraphElement;
+    stylesNames: TextStylesNames;
+    vars: TextCssVariables;
+    variant: TextVariant;
+}> & Record<string, never>;
+export {};

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

@@ -0,0 +1,2 @@
+export { Text } from './Text';
+export type { TextCssVariables, TextFactory, TextProps, TextStylesNames, TextVariant, } from './Text';

package/lib/components/TextInput/TextInput.d.ts

@@ -0,0 +1,15 @@
+import { ElementProps, Factory } from '../../core';
+import { InputBaseProps } from '../InputBase';
+import { __InputStylesNames } from '../Input';
+export interface TextInputProps extends InputBaseProps, ElementProps<'input', 'size'> {
+}
+export type TextInputFactory = Factory<{
+    props: TextInputProps;
+    ref: HTMLInputElement;
+    stylesNames: __InputStylesNames;
+}>;
+export declare const TextInput: import("../../core").MantineComponent<{
+    props: TextInputProps;
+    ref: HTMLInputElement;
+    stylesNames: __InputStylesNames;
+}>;

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

@@ -0,0 +1,2 @@
+export { TextInput } from './TextInput';
+export type { TextInputFactory, TextInputProps } from './TextInput';

package/lib/components/Title/Title.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { StylesApiProps, ElementProps, Factory, BoxProps } from '../../core';
+export type TitleOrder = 1 | 2 | 3 | 4 | 5 | 6;
+export type TitleSize = `h${TitleOrder}` | React.CSSProperties['fontSize'];
+export type TitleStylesNames = 'root';
+export type TitleVariant = string;
+export type TitleCssVariables = {
+    root: '--title-fw' | '--title-lh' | '--title-fz';
+};
+export interface TitleProps extends BoxProps, StylesApiProps<TitleFactory>, ElementProps<'h1'> {
+    /** Determines which tag will be used (h1-h6), controls `font-size` style if `size` prop is not set, `1` by default */
+    order?: TitleOrder;
+    /** Changes title size, if not set, then size is controlled by `order` prop */
+    size?: TitleSize;
+}
+export type TitleFactory = Factory<{
+    props: TitleProps;
+    ref: HTMLHeadingElement;
+    stylesNames: TitleStylesNames;
+    vars: TitleCssVariables;
+    variant: TitleVariant;
+}>;
+export declare const Title: import("../../core").MantineComponent<{
+    props: TitleProps;
+    ref: HTMLHeadingElement;
+    stylesNames: TitleStylesNames;
+    vars: TitleCssVariables;
+    variant: TitleVariant;
+}>;

package/lib/components/Title/get-title-size.d.ts

@@ -0,0 +1,7 @@
+import type { TitleSize, TitleOrder } from './Title';
+export interface GetTitleSizeResult {
+    fontSize: string;
+    fontWeight: string;
+    lineHeight: string;
+}
+export declare function getTitleSize(order: TitleOrder, size: TitleSize | undefined): GetTitleSizeResult;

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

@@ -0,0 +1,2 @@
+export { Title } from './Title';
+export type { TitleProps, TitleOrder, TitleSize, TitleStylesNames, TitleCssVariables, TitleFactory, TitleVariant, } from './Title';