@mantine/core 6.0.9 → 7.0.0-alpha.2

package/lib/components/Input/use-input-props.d.ts

@@ -0,0 +1,307 @@
+import { BoxProps, StylesApiProps } from '../../core';
+import { __BaseInputProps } from './Input';
+interface BaseProps extends __BaseInputProps, BoxProps, StylesApiProps<{
+    props: any;
+    stylesNames: string;
+}> {
+    __staticSelector?: string;
+    __stylesApiProps?: Record<string, any>;
+    id?: string;
+}
+export declare function useInputProps<T extends BaseProps, U extends Partial<T>>(component: string, defaultProps: U, _props: T): Omit<T & { [Key in Extract<keyof T, never>]-?: {}[Key] | NonNullable<T[Key]>; }, "label" | "style" | "size" | "variant" | "error" | "className" | "id" | "classNames" | "styles" | "vars" | "description" | "required" | "unstyled" | "__staticSelector" | "__stylesApiProps" | "withAsterisk" | "labelProps" | "descriptionProps" | "errorProps" | "inputContainer" | "inputWrapperOrder" | "wrapperProps"> & {
+    classNames: Partial<Record<string, string>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, string>>) | undefined;
+    styles: Partial<Record<string, import("react").CSSProperties>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, import("react").CSSProperties>>) | undefined;
+    unstyled: boolean | undefined;
+    wrapperProps: {
+        children?: import("react").ReactNode;
+        slot?: string | undefined;
+        style: import("../../core").MantineStyleProp;
+        title?: string | undefined;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        dir?: string | undefined;
+        color?: string | undefined;
+        key?: import("react").Key | null | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        className: string | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | undefined;
+        contextMenu?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        hidden?: boolean | undefined;
+        id: string;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        placeholder?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        tabIndex?: number | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: import("react").AriaRole | undefined;
+        about?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        resource?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCapitalize?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+        is?: string | undefined;
+        'aria-activedescendant'?: string | undefined;
+        'aria-atomic'?: (boolean | "true" | "false") | undefined;
+        'aria-autocomplete'?: "none" | "list" | "inline" | "both" | undefined;
+        'aria-busy'?: (boolean | "true" | "false") | undefined;
+        'aria-checked'?: boolean | "true" | "false" | "mixed" | undefined;
+        'aria-colcount'?: number | undefined;
+        'aria-colindex'?: number | undefined;
+        'aria-colspan'?: number | undefined;
+        'aria-controls'?: string | undefined;
+        'aria-current'?: boolean | "time" | "true" | "false" | "page" | "step" | "location" | "date" | undefined;
+        'aria-describedby'?: string | undefined;
+        'aria-details'?: string | undefined;
+        'aria-disabled'?: (boolean | "true" | "false") | undefined;
+        'aria-dropeffect'?: "link" | "none" | "copy" | "execute" | "move" | "popup" | undefined;
+        'aria-errormessage'?: string | undefined;
+        'aria-expanded'?: (boolean | "true" | "false") | undefined;
+        'aria-flowto'?: string | undefined;
+        'aria-grabbed'?: (boolean | "true" | "false") | undefined;
+        'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree" | undefined;
+        'aria-hidden'?: (boolean | "true" | "false") | undefined;
+        'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+        'aria-keyshortcuts'?: string | undefined;
+        'aria-label'?: string | undefined;
+        'aria-labelledby'?: string | undefined;
+        'aria-level'?: number | undefined;
+        'aria-live'?: "off" | "assertive" | "polite" | undefined;
+        'aria-modal'?: (boolean | "true" | "false") | undefined;
+        'aria-multiline'?: (boolean | "true" | "false") | undefined;
+        'aria-multiselectable'?: (boolean | "true" | "false") | undefined;
+        'aria-orientation'?: "vertical" | "horizontal" | undefined;
+        'aria-owns'?: string | undefined;
+        'aria-placeholder'?: string | undefined;
+        'aria-posinset'?: number | undefined;
+        'aria-pressed'?: boolean | "true" | "false" | "mixed" | undefined;
+        'aria-readonly'?: (boolean | "true" | "false") | undefined;
+        'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+        'aria-required'?: (boolean | "true" | "false") | undefined;
+        'aria-roledescription'?: string | undefined;
+        'aria-rowcount'?: number | undefined;
+        'aria-rowindex'?: number | undefined;
+        'aria-rowspan'?: number | undefined;
+        'aria-selected'?: (boolean | "true" | "false") | undefined;
+        'aria-setsize'?: number | undefined;
+        'aria-sort'?: "none" | "other" | "ascending" | "descending" | undefined;
+        'aria-valuemax'?: number | undefined;
+        'aria-valuemin'?: number | undefined;
+        'aria-valuenow'?: number | undefined;
+        'aria-valuetext'?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string;
+        } | undefined;
+        onCopy?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCut?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onPaste?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+        onFocus?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+        onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+        onBlur?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+        onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+        onChange?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onChangeCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onBeforeInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onReset?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onResetCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onSubmit?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onInvalid?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+        onLoad?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onError?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+        onAbort?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onDurationChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEmptied?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEncrypted?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEnded?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedData?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadStart?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPause?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPlaying?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onProgress?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onRateChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onResize?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSeeked?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSeeking?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onStalled?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSuspend?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onWaiting?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onAuxClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onContextMenu?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onDrag?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnd?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnter?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragExit?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragLeave?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragOver?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragStart?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDrop?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onDropCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+        onMouseDown?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseMove?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOut?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOver?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseUp?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+        onSelect?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchMove?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchStart?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+        onPointerDown?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerMove?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerUp?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOver?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOut?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+        onScroll?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+        onScrollCapture?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+        onWheel?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+        label: import("react").ReactNode;
+        description: import("react").ReactNode;
+        error: import("react").ReactNode;
+        required: boolean | undefined;
+        classNames: Partial<Record<string, string>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, string>>) | undefined;
+        __staticSelector: string | undefined;
+        __stylesApiProps: Record<string, any>;
+        errorProps: Record<string, any> | undefined;
+        labelProps: Record<string, any> | undefined;
+        descriptionProps: Record<string, any> | undefined;
+        unstyled: boolean | undefined;
+        styles: Partial<Record<string, import("react").CSSProperties>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, import("react").CSSProperties>>) | undefined;
+        size: (string & {}) | import("../../core").MantineSize | undefined;
+        inputContainer: ((children: import("react").ReactNode) => import("react").ReactNode) | undefined;
+        inputWrapperOrder: ("input" | "label" | "error" | "description")[] | undefined;
+        withAsterisk: boolean | undefined;
+        variant: string | undefined;
+    } & BoxProps;
+    inputProps: {
+        required: boolean | undefined;
+        classNames: Partial<Record<string, string>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, string>>) | undefined;
+        styles: Partial<Record<string, import("react").CSSProperties>> | ((theme: import("../../core").MantineTheme, props: any, ctx: unknown) => Partial<Record<string, import("react").CSSProperties>>) | undefined;
+        unstyled: boolean | undefined;
+        id: string;
+        size: (string & {}) | import("../../core").MantineSize | undefined;
+        __staticSelector: string | undefined;
+        __stylesApiProps: Record<string, any>;
+        error: import("react").ReactNode;
+        variant: string | undefined;
+    };
+};
+export {};

package/lib/components/InputBase/InputBase.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, PolymorphicFactory } from '../../core';
+import { __InputStylesNames, __BaseInputProps, InputVariant } from '../Input';
+export interface InputBaseProps extends BoxProps, __BaseInputProps, StylesApiProps<InputBaseFactory> {
+    __staticSelector?: string;
+    /** Props passed to the root element (`Input.Wrapper` component) */
+    wrapperProps?: Record<string, any>;
+}
+export type InputBaseFactory = PolymorphicFactory<{
+    props: InputBaseProps;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: __InputStylesNames;
+    variant: InputVariant;
+}>;
+export declare const InputBase: (<C = "input">(props: import("../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, InputBaseProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(InputBaseProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof InputBaseProps> & {
+    ref?: any;
+}) | (InputBaseProps & {
+    component: React.ElementType<any>;
+})>, never> & import("../../core/factory/factory").ThemeExtend<{
+    props: InputBaseProps;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: __InputStylesNames;
+    variant: InputVariant;
+}> & Record<string, never>;

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

@@ -0,0 +1,2 @@
+export { InputBase } from './InputBase';
+export type { InputBaseFactory, InputBaseProps } from './InputBase';

package/lib/components/Kbd/Kbd.d.ts

@@ -0,0 +1,24 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineSize } from '../../core';
+export type KbdStylesNames = 'root';
+export type KbdVariant = string;
+export type KbdCssVariables = {
+    root: '--kbd-padding' | '--kbd-fz';
+};
+export interface KbdProps extends BoxProps, StylesApiProps<KbdFactory>, ElementProps<'kbd'> {
+    /** Controls font-size and padding, `'sm'` by default */
+    size?: MantineSize | (string & {});
+}
+export type KbdFactory = Factory<{
+    props: KbdProps;
+    ref: HTMLElement;
+    stylesNames: KbdStylesNames;
+    vars: KbdCssVariables;
+    variant: KbdVariant;
+}>;
+export declare const Kbd: import("../../core").MantineComponent<{
+    props: KbdProps;
+    ref: HTMLElement;
+    stylesNames: KbdStylesNames;
+    vars: KbdCssVariables;
+    variant: KbdVariant;
+}>;

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

@@ -0,0 +1,2 @@
+export { Kbd } from './Kbd';
+export type { KbdCssVariables, KbdFactory, KbdProps, KbdStylesNames, KbdVariant } from './Kbd';

package/lib/components/Loader/Loader.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { MantineSize, MantineColor, BoxProps, StylesApiProps, Factory } from '../../core';
+import type { MantineLoader, MantineLoadersRecord } from './Loader.types';
+export type LoaderStylesNames = 'root';
+export type LoaderVariant = string;
+export type LoaderCssVariables = {
+    root: '--loader-size' | '--loader-color';
+};
+export interface LoaderProps extends BoxProps, StylesApiProps<LoaderFactory>, Omit<React.ComponentPropsWithoutRef<'svg'>, keyof BoxProps> {
+    /** Width/height of the loader. Loader has predefined xs-xl values, number value (in px) is converted to rem `(1rem = 16px)`. */
+    size?: MantineSize | (string & {}) | number;
+    /** Key of `theme.colors` or any valid CSS color, default value is `theme.primaryColor`  */
+    color?: MantineColor;
+    /** Loader type, key of `loaders` prop, default value is `'oval'` */
+    type?: MantineLoader;
+    /** Object of loaders components, can be customized via default props or inline. Default value contains `bars`, `oval` and `dots` */
+    loaders?: MantineLoadersRecord;
+}
+export type LoaderFactory = Factory<{
+    props: LoaderProps;
+    ref: HTMLSpanElement;
+    stylesNames: LoaderStylesNames;
+    vars: LoaderCssVariables;
+    staticComponents: {
+        defaultLoaders: typeof defaultLoaders;
+    };
+}>;
+export declare const defaultLoaders: MantineLoadersRecord;
+export declare const Loader: import("../../core").MantineComponent<{
+    props: LoaderProps;
+    ref: HTMLSpanElement;
+    stylesNames: LoaderStylesNames;
+    vars: LoaderCssVariables;
+    staticComponents: {
+        defaultLoaders: typeof defaultLoaders;
+    };
+}>;

package/lib/components/Loader/Loader.types.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface SvgLoaderProps extends React.ComponentPropsWithoutRef<any> {
+}
+export type MantineLoaderComponent = React.ForwardRefExoticComponent<React.HTMLAttributes<any> & React.RefAttributes<any>>;
+export type MantineLoadersRecord = Partial<Record<'bars' | 'dots' | 'oval' | (string & {}), MantineLoaderComponent>>;
+export type MantineLoader = keyof MantineLoadersRecord;

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

@@ -0,0 +1,3 @@
+export { Loader, defaultLoaders } from './Loader';
+export type { MantineLoader, SvgLoaderProps, MantineLoadersRecord, MantineLoaderComponent, } from './Loader.types';
+export type { LoaderProps, LoaderStylesNames, LoaderCssVariables, LoaderFactory } from './Loader';

package/lib/components/Loader/loaders/Bars.d.ts

@@ -0,0 +1,2 @@
+import { MantineLoaderComponent } from '../Loader.types';
+export declare const Bars: MantineLoaderComponent;

package/lib/components/Loader/loaders/Dots.d.ts

@@ -0,0 +1,2 @@
+import { MantineLoaderComponent } from '../Loader.types';
+export declare const Dots: MantineLoaderComponent;

package/lib/components/Loader/loaders/Oval.d.ts

@@ -0,0 +1,2 @@
+import { MantineLoaderComponent } from '../Loader.types';
+export declare const Oval: MantineLoaderComponent;

package/lib/components/Mark/Mark.d.ts

@@ -0,0 +1,22 @@
+import { BoxProps, StylesApiProps, ElementProps, MantineColor, Factory } from '../../core';
+export type MarkStylesNames = 'root';
+export type MarkVariant = string;
+export type MarkCssVariables = {
+    root: '--mark-bg-dark' | '--mark-bg-light';
+};
+export interface MarkProps extends BoxProps, StylesApiProps<MarkFactory>, ElementProps<'mark'> {
+    /** Key of `theme.colors` or any valid CSS color, `yellow` by default */
+    color?: MantineColor;
+}
+export type MarkFactory = Factory<{
+    props: MarkProps;
+    ref: HTMLElement;
+    stylesNames: MarkStylesNames;
+    vars: MarkCssVariables;
+}>;
+export declare const Mark: import("../../core").MantineComponent<{
+    props: MarkProps;
+    ref: HTMLElement;
+    stylesNames: MarkStylesNames;
+    vars: MarkCssVariables;
+}>;

package/lib/components/Mark/get-mark-color.d.ts

@@ -0,0 +1,8 @@
+import { MantineColor, MantineTheme } from '../../core';
+interface GetMarkColorInput {
+    color: MantineColor | string | undefined;
+    theme: MantineTheme;
+    defaultShade: number;
+}
+export declare function getMarkColor({ color, theme, defaultShade }: GetMarkColorInput): string | undefined;
+export {};

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

@@ -0,0 +1,2 @@
+export { Mark } from './Mark';
+export type { MarkProps, MarkCssVariables, MarkFactory, MarkStylesNames } from './Mark';

package/lib/components/NativeSelect/NativeSelect.d.ts

@@ -0,0 +1,18 @@
+import { ElementProps, Factory } from '../../core';
+import { InputBaseProps } from '../InputBase';
+import { __InputStylesNames } from '../Input';
+import { ComboboxData } from '../Combobox';
+export interface NativeSelectProps extends InputBaseProps, ElementProps<'select', 'size'> {
+    /** Data used to render options, can be replaced with `children` */
+    data?: ComboboxData;
+}
+export type NativeSelectFactory = Factory<{
+    props: NativeSelectProps;
+    ref: HTMLSelectElement;
+    stylesNames: __InputStylesNames;
+}>;
+export declare const NativeSelect: import("../../core").MantineComponent<{
+    props: NativeSelectProps;
+    ref: HTMLSelectElement;
+    stylesNames: __InputStylesNames;
+}>;

package/lib/components/NativeSelect/NativeSelectOption.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ComboboxParsedItem } from '../Combobox';
+export interface NativeSelectOptionProps {
+    data: ComboboxParsedItem;
+}
+export declare function NativeSelectOption({ data }: NativeSelectOptionProps): JSX.Element;
+export declare namespace NativeSelectOption {
+    var displayName: string;
+}

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

@@ -0,0 +1,2 @@
+export { NativeSelect } from './NativeSelect';
+export type { NativeSelectFactory, NativeSelectProps } from './NativeSelect';

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, MantineShadow, MantineRadius, PolymorphicFactory } from '../../core';
+export type PaperStylesNames = 'root';
+export type PaperVariant = string;
+export type PaperCssVariables = {
+    root: '--paper-radius' | '--paper-shadow';
+};
+export interface PaperProps extends BoxProps, StylesApiProps<PaperFactory> {
+    /** Key of `theme.shadows` or any valid CSS value to set box-shadow, `none` by default */
+    shadow?: MantineShadow | (string & {});
+    /** Key of `theme.radius` or any valid CSS value to set border-radius, numbers are converted to rem (1rem = 16px), `theme.defaultRadius` by default */
+    radius?: MantineRadius | number | (string & {});
+    /** Determines whether the paper should have border, border color depends on color scheme, `false` by default */
+    withBorder?: boolean;
+}
+export type PaperFactory = PolymorphicFactory<{
+    props: PaperProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLDivElement;
+    stylesNames: PaperStylesNames;
+    vars: PaperCssVariables;
+}>;
+export declare const Paper: (<C = "div">(props: import("../../core/factory/create-polymorphic-component").PolymorphicComponentProps<C, PaperProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & Omit<React.FunctionComponent<(PaperProps & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof PaperProps> & {
+    ref?: any;
+}) | (PaperProps & {
+    component: React.ElementType<any>;
+})>, never> & import("../../core/factory/factory").ThemeExtend<{
+    props: PaperProps;
+    defaultComponent: 'div';
+    defaultRef: HTMLDivElement;
+    stylesNames: PaperStylesNames;
+    vars: PaperCssVariables;
+}> & Record<string, never>;

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

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

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

@@ -0,0 +1,53 @@
+/// <reference types="react" />
+import { MantineShadow, Styles, ClassNames, MantineRadius, GetStylesApi } from '../../core';
+import { FloatingPosition, ArrowPosition } from '../Floating';
+import { TransitionOverride } from '../Transition';
+import { PortalProps } from '../Portal';
+import { PopoverWidth } from './Popover.types';
+import type { PopoverFactory } from './Popover';
+interface PopoverContext {
+    x: number;
+    y: number;
+    arrowX: number;
+    arrowY: number;
+    arrowRef: React.RefObject<HTMLDivElement>;
+    opened: boolean;
+    transitionProps?: TransitionOverride;
+    reference(node: HTMLElement): void;
+    floating(node: HTMLElement): void;
+    width?: PopoverWidth;
+    withArrow: boolean | undefined;
+    arrowSize: number;
+    arrowOffset: number;
+    arrowRadius: number;
+    arrowPosition: ArrowPosition;
+    trapFocus: boolean | undefined;
+    placement: FloatingPosition;
+    withinPortal: boolean | undefined;
+    portalProps?: Omit<PortalProps, 'children'>;
+    closeOnEscape: boolean | undefined;
+    zIndex: React.CSSProperties['zIndex'];
+    radius?: MantineRadius | (string & {}) | number | undefined;
+    shadow?: MantineShadow | (string & {}) | undefined;
+    onClose?(): void;
+    getDropdownId(): string;
+    getTargetId(): string;
+    controlled: boolean;
+    onToggle(): void;
+    withRoles: boolean | undefined;
+    targetProps: Record<string, any>;
+    disabled: boolean | undefined;
+    returnFocus: boolean | undefined;
+    classNames: ClassNames<PopoverFactory> | undefined;
+    styles: Styles<PopoverFactory> | undefined;
+    unstyled: boolean | undefined;
+    __staticSelector: string;
+    variant: string | undefined;
+    keepMounted: boolean | undefined;
+    getStyles: GetStylesApi<PopoverFactory>;
+}
+export declare const PopoverContextProvider: ({ children, value }: {
+    value: PopoverContext;
+    children: import("react").ReactNode;
+}) => JSX.Element, usePopoverContext: () => PopoverContext;
+export {};