@banzamel/mineralui 0.2.1 → 0.4.1

package/dist/index.d.ts

@@ -1,15 +1,41 @@
+import { AnchorHTMLAttributes } from 'react';
+import { AnimationEventHandler } from 'react';
+import { AriaRole } from 'react';
+import { ButtonHTMLAttributes } from 'react';
 import { ChangeEvent } from 'react';
+import { ClipboardEventHandler } from 'react';
+import { CompositionEventHandler } from 'react';
 import { CSSProperties } from 'react';
+import { DetailedReactHTMLElement } from 'react';
 import { Dispatch } from 'react';
+import { DragEventHandler } from 'react';
+import { ElementType } from 'react';
 import { FocusEvent as FocusEvent_2 } from 'react';
+import { FocusEventHandler } from 'react';
+import { FormEventHandler } from 'react';
 import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { InputEventHandler } from 'react';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import { KeyboardEvent as KeyboardEvent_2 } from 'react';
+import { KeyboardEventHandler } from 'react';
+import { MouseEventHandler } from 'react';
+import { PointerEvent as PointerEvent_2 } from 'react';
+import { PointerEventHandler } from 'react';
+import { ReactElement } from 'react';
+import { ReactEventHandler } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
 import { RefAttributes } from 'react';
 import { RefObject } from 'react';
 import { SetStateAction } from 'react';
+import { TableHTMLAttributes } from 'react';
+import { TdHTMLAttributes } from 'react';
+import { ThHTMLAttributes } from 'react';
+import { TouchEventHandler } from 'react';
+import { TransitionEventHandler } from 'react';
+import { UIEventHandler } from 'react';
+import { WheelEventHandler } from 'react';
 
 export declare function addMonths(date: Date, count: number): Date;
 
@@ -17,9 +43,24 @@ export declare function addYears(date: Date, count: number): Date;
 
 export declare function adjustCursorAfterFormat(oldValue: string, newValue: string, oldCursor: number): number;
 
-export declare function Autocomplete<T = string>({ options, value, onChange, getOptionLabel, getOptionValue, filterOptions, multiple, freeSolo, debounceMs, onInputChange, loading, loadingText, noOptionsText, placeholder, disabled, name, id, variant, size, fullWidth, label, helperText, errorText, error, required, clearable, maxHeight, renderOption, renderTags, className, style, }: AutocompleteProps<T>): JSX_2.Element;
+declare function Alert({ color, fcolor, title, className, children, ...rest }: AlertProps): JSX_2.Element;
+export { Alert }
+export { Alert as MAlert }
 
-export declare interface AutocompleteProps<T = string> {
+declare interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    title?: ReactNode;
+    children?: ReactNode;
+}
+export { AlertProps }
+export { AlertProps as MAlertProps }
+
+declare function Autocomplete<T = string>({ options, value, onChange, getOptionLabel, getOptionValue, filterOptions, multiple, freeSolo, debounceMs, onInputChange, loading, loadingText, noOptionsText, placeholder, disabled, name, id, variant, size, color, fcolor, fullWidth, label, helperText, errorText, error, required, clearable, maxHeight, renderOption, renderTags, className, style, }: AutocompleteProps<T>): JSX_2.Element;
+export { Autocomplete }
+export { Autocomplete as MAutocomplete }
+
+declare interface AutocompleteProps<T = string> {
     options: T[];
     value?: T | T[];
     onChange?: (value: T | T[]) => void;
@@ -40,6 +81,7 @@ export declare interface AutocompleteProps<T = string> {
     variant?: AutocompleteVariant;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     fullWidth?: boolean;
     label?: string;
     helperText?: string;
@@ -53,14 +95,310 @@ export declare interface AutocompleteProps<T = string> {
     className?: string;
     style?: CSSProperties;
 }
+export { AutocompleteProps }
+export { AutocompleteProps as MAutocompleteProps }
+
+declare type AutocompleteVariant = 'outlined' | 'filled' | 'underlined';
+export { AutocompleteVariant }
+export { AutocompleteVariant as MAutocompleteVariant }
+
+declare function Avatar({ src, alt, name, initials, size, shape, color, fcolor, backgroundColor, clickEffect, rippleColor, className, style, onPointerDown, ...rest }: AvatarProps): JSX_2.Element;
+export { Avatar }
+export { Avatar as MAvatar }
+
+declare interface AvatarProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    src?: string;
+    alt?: string;
+    name?: string;
+    initials?: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    backgroundColor?: string;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
+    style?: CSSProperties;
+}
+export { AvatarProps }
+export { AvatarProps as MAvatarProps }
+
+declare type AvatarShape = 'circle' | 'rounded' | 'square';
+export { AvatarShape }
+export { AvatarShape as MAvatarShape }
+
+declare type AvatarSize = 'sm' | 'md' | 'lg' | number;
+export { AvatarSize }
+export { AvatarSize as MAvatarSize }
+
+declare function Badge({ color, size, fcolor, className, children, ...rest }: BadgeProps): JSX_2.Element;
+export { Badge }
+export { Badge as MBadge }
+
+declare interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    color?: MineralColor;
+    size?: MineralSize;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+export { BadgeProps }
+export { BadgeProps as MBadgeProps }
+
+declare const Button: ForwardRefExoticComponent<ButtonProps & RefAttributes<HTMLButtonElement>>;
+export { Button }
+export { Button as MButton }
+
+declare interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color'> {
+    variant?: ButtonVariant;
+    size?: MineralSize;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    fullWidth?: boolean;
+    rounded?: boolean;
+    iconOnly?: boolean;
+    loading?: boolean;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export { ButtonProps }
+export { ButtonProps as MButtonProps }
+
+declare type ButtonVariant = 'primary' | 'secondary' | 'outlined' | 'ghost' | 'link';
+export { ButtonVariant }
+export { ButtonVariant as MButtonVariant }
+
+declare function CalendarBoard({ month, defaultMonth, onMonthChange, events, locale, weekStartsOn, view, defaultView, views, onViewChange, selectedDate, defaultSelectedDate, onDayClick, dayBadge, renderDayCell, renderEventItem, detailsTrigger, detailsMode, showTimeline, timelineStartHour, timelineEndHour, emptyStateText, filters, activeFilters, defaultActiveFilters, onActiveFiltersChange, fullWidth, className, ...rest }: CalendarBoardProps): JSX_2.Element;
+export { CalendarBoard }
+export { CalendarBoard as MCalendarBoard }
+
+declare type CalendarBoardLocale = 'pl' | 'en';
+export { CalendarBoardLocale }
+export { CalendarBoardLocale as MCalendarBoardLocale }
+
+declare interface CalendarBoardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    month?: Date;
+    defaultMonth?: Date;
+    onMonthChange?: (month: Date) => void;
+    events?: CalendarEvent[];
+    locale?: CalendarBoardLocale;
+    weekStartsOn?: 0 | 1;
+    view?: CalendarBoardView;
+    defaultView?: CalendarBoardView;
+    views?: CalendarBoardView[];
+    onViewChange?: (view: CalendarBoardView) => void;
+    selectedDate?: Date | string | null;
+    defaultSelectedDate?: Date | string | null;
+    onDayClick?: (day: Date, events: CalendarEvent[]) => void;
+    dayBadge?: (day: Date, events: CalendarEvent[]) => ReactNode;
+    renderDayCell?: (day: Date, context: CalendarDayRenderContext) => ReactNode;
+    renderEventItem?: (event: CalendarEvent) => ReactNode;
+    detailsTrigger?: CalendarDetailsTrigger;
+    detailsMode?: CalendarDetailsMode;
+    showTimeline?: boolean;
+    timelineStartHour?: number;
+    timelineEndHour?: number;
+    emptyStateText?: string;
+    filters?: CalendarFilterOption[];
+    activeFilters?: string[];
+    defaultActiveFilters?: string[];
+    onActiveFiltersChange?: (activeFilters: string[]) => void;
+    fullWidth?: boolean;
+}
+export { CalendarBoardProps }
+export { CalendarBoardProps as MCalendarBoardProps }
+
+declare type CalendarBoardView = 'month' | 'week';
+export { CalendarBoardView }
+export { CalendarBoardView as MCalendarBoardView }
+
+declare function CalendarDayCell({ date, events, badge, markers, isToday, isSelected, isOutsideMonth, className, children, ...rest }: CalendarDayCellProps): JSX_2.Element;
+export { CalendarDayCell }
+export { CalendarDayCell as MCalendarDayCell }
+
+declare interface CalendarDayCellProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color'> {
+    date: Date;
+    events?: CalendarEvent[];
+    badge?: ReactNode;
+    markers?: ReactNode;
+    isToday?: boolean;
+    isSelected?: boolean;
+    isOutsideMonth?: boolean;
+    children?: ReactNode;
+}
+export { CalendarDayCellProps }
+export { CalendarDayCellProps as MCalendarDayCellProps }
+
+declare interface CalendarDayRenderContext {
+    date: Date;
+    events: CalendarEvent[];
+    badge: ReactNode;
+    isToday: boolean;
+    isSelected: boolean;
+    isOutsideMonth: boolean;
+}
+export { CalendarDayRenderContext }
+export { CalendarDayRenderContext as MCalendarDayRenderContext }
+
+declare type CalendarDetailsMode = 'auto' | 'popover' | 'modal';
+export { CalendarDetailsMode }
+export { CalendarDetailsMode as MCalendarDetailsMode }
+
+declare type CalendarDetailsTrigger = 'click' | 'hover';
+export { CalendarDetailsTrigger }
+export { CalendarDetailsTrigger as MCalendarDetailsTrigger }
+
+declare interface CalendarEvent {
+    id: string;
+    title: string;
+    description?: string;
+    date: string | Date;
+    startTime?: string;
+    endTime?: string;
+    type?: string;
+    status?: CalendarEventStatus;
+    color?: string;
+    badgeLabel?: string;
+    user?: CalendarEventUser;
+    meta?: Record<string, unknown>;
+}
+export { CalendarEvent }
+export { CalendarEvent as MCalendarEvent }
+
+declare function CalendarEventItem({ event, locale, className, currentDate, ...rest }: CalendarEventItemProps): JSX_2.Element;
+export { CalendarEventItem }
+export { CalendarEventItem as MCalendarEventItem }
 
-export declare type AutocompleteVariant = 'outlined' | 'filled' | 'underlined';
+declare interface CalendarEventItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    event: CalendarEvent;
+    locale?: CalendarBoardLocale;
+    currentDate?: Date;
+}
+export { CalendarEventItemProps }
+export { CalendarEventItemProps as MCalendarEventItemProps }
+
+declare function CalendarEventList({ events, locale, currentDate, emptyStateText, renderEventItem, className, ...rest }: CalendarEventListProps): JSX_2.Element;
+export { CalendarEventList }
+export { CalendarEventList as MCalendarEventList }
+
+declare interface CalendarEventListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    events: CalendarEvent[];
+    locale?: CalendarBoardLocale;
+    currentDate?: Date;
+    emptyStateText?: string;
+    renderEventItem?: (event: CalendarEvent) => ReactNode;
+}
+export { CalendarEventListProps }
+export { CalendarEventListProps as MCalendarEventListProps }
+
+declare function CalendarEventPopover({ open, anchorRef, onClose, onPointerEnter, onPointerLeave, date, events, locale, timelineStartHour, timelineEndHour, showTimeline, emptyStateText, renderEventItem, className, style, }: CalendarEventPopoverProps): JSX_2.Element;
+export { CalendarEventPopover }
+export { CalendarEventPopover as MCalendarEventPopover }
+
+declare interface CalendarEventPopoverProps {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    onClose: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    date: Date | null;
+    events: CalendarEvent[];
+    locale?: CalendarBoardLocale;
+    timelineStartHour?: number;
+    timelineEndHour?: number;
+    showTimeline?: boolean;
+    emptyStateText?: string;
+    className?: string;
+    style?: CSSProperties;
+    renderEventItem?: (event: CalendarEvent) => ReactNode;
+}
+export { CalendarEventPopoverProps }
+export { CalendarEventPopoverProps as MCalendarEventPopoverProps }
+
+declare type CalendarEventStatus = 'planned' | 'active' | 'done' | 'cancelled';
+export { CalendarEventStatus }
+export { CalendarEventStatus as MCalendarEventStatus }
+
+declare interface CalendarEventUser {
+    id: string;
+    name: string;
+    avatar?: string;
+    color?: string;
+}
+export { CalendarEventUser }
+export { CalendarEventUser as MCalendarEventUser }
+
+declare interface CalendarFilterOption {
+    id: string;
+    label: string;
+    color?: string;
+    predicate: (event: CalendarEvent) => boolean;
+}
+export { CalendarFilterOption }
+export { CalendarFilterOption as MCalendarFilterOption }
+
+declare function CalendarTimeline({ date, events, locale, startHour, endHour, emptyStateText, className, ...rest }: CalendarTimelineProps): JSX_2.Element;
+export { CalendarTimeline }
+export { CalendarTimeline as MCalendarTimeline }
+
+declare interface CalendarTimelineProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    date: Date;
+    events: CalendarEvent[];
+    locale?: CalendarBoardLocale;
+    startHour?: number;
+    endHour?: number;
+    emptyStateText?: string;
+}
+export { CalendarTimelineProps }
+export { CalendarTimelineProps as MCalendarTimelineProps }
+
+declare type CalendarTimelineSlotState = 'past' | 'active' | 'upcoming';
+export { CalendarTimelineSlotState }
+export { CalendarTimelineSlotState as MCalendarTimelineSlotState }
 
 export declare function capitalizeWords(value: string): string;
 
-export declare const Checkbox: ForwardRefExoticComponent<CheckboxProps & RefAttributes<HTMLInputElement>>;
+declare function Card({ interactive, stretch, tone, padded, color, fcolor, clickEffect, rippleColor, className, children, onPointerDown, ...rest }: CardProps): JSX_2.Element;
+export { Card }
+export { Card as MCard }
+
+declare function CardBody({ className, children, ...rest }: CardSectionProps): JSX_2.Element;
+export { CardBody }
+export { CardBody as MCardBody }
+
+declare function CardFooter({ className, children, ...rest }: CardSectionProps): JSX_2.Element;
+export { CardFooter }
+export { CardFooter as MCardFooter }
 
-export declare interface CheckboxProps {
+declare function CardHeader({ className, children, ...rest }: CardSectionProps): JSX_2.Element;
+export { CardHeader }
+export { CardHeader as MCardHeader }
+
+declare interface CardProps extends Omit<SurfaceProps, 'children'> {
+    interactive?: boolean;
+    stretch?: boolean;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
+    children?: ReactNode;
+}
+export { CardProps }
+export { CardProps as MCardProps }
+
+declare interface CardSectionProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const Checkbox: ForwardRefExoticComponent<CheckboxProps & RefAttributes<HTMLInputElement>>;
+export { Checkbox }
+export { Checkbox as MCheckbox }
+
+declare interface CheckboxProps {
     checked?: boolean;
     defaultChecked?: boolean;
     indeterminate?: boolean;
@@ -70,32 +408,93 @@ export declare interface CheckboxProps {
     disabled?: boolean;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     label?: ReactNode;
     labelPosition?: 'right' | 'left';
     error?: boolean;
     errorText?: string;
     onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
     className?: string;
     style?: CSSProperties;
 }
+export { CheckboxProps }
+export { CheckboxProps as MCheckboxProps }
+
+declare function cn(...classes: (string | undefined | null | false)[]): string;
+export { cn }
+export { cn as mergeClasses }
+
+declare function Code({ color, fcolor, className, children, ...rest }: CodeProps): JSX_2.Element;
+export { Code }
+export { Code as MCode }
 
-/**
- * Łączy klasy CSS, odfiltrowując falsy wartości.
- * Lekki zamiennik clsx/classnames — zero dependencies.
- */
-export declare function cn(...classes: (string | undefined | null | false)[]): string;
+declare interface CodeProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+export { CodeProps }
+export { CodeProps as MCodeProps }
+
+declare function Collapsible({ title, defaultOpen, open: controlledOpen, onToggle, fcolor, className, children, ...rest }: CollapsibleProps): JSX_2.Element;
+export { Collapsible }
+export { Collapsible as MCollapsible }
+
+declare interface CollapsibleProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    title: ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onToggle?: (open: boolean) => void;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+export { CollapsibleProps }
+export { CollapsibleProps as MCollapsibleProps }
 
 export declare function composeValidators(...validators: ValidatorFn[]): ValidatorFn;
 
+declare function Container({ size, padded, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: ContainerProps): JSX_2.Element;
+export { Container }
+export { Container as MContainer }
+
+declare interface ContainerProps extends HTMLAttributes<HTMLDivElement>, LayoutUtilityProps {
+    size?: ContainerSize;
+    padded?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export { ContainerProps }
+export { ContainerProps as MContainerProps }
+
+export declare type ContainerSize = 'content' | 'wide' | 'full';
+
+export declare type CreditCardBrand = 'visa' | 'mastercard' | 'amex' | 'discover' | 'maestro' | 'unknown';
+
+export declare interface CreditCardBrandDetails {
+    brand: CreditCardBrand;
+    label: string;
+    iconLabel: string;
+    maxLength: number;
+    formatGroups: number[];
+    regex: RegExp;
+}
+
+export declare const creditCardBrands: CreditCardBrandDetails[];
+
 export declare interface CurrencyFormatOptions {
     decimalSeparator?: '.' | ',';
     thousandSeparator?: ' ' | '.' | ',' | '';
     precision?: number;
 }
 
-export declare function DatePicker({ value, defaultValue, onChange, format, locale, min, max, disabledDates, placeholder, disabled, readOnly, name, id, variant, size, label, helperText, errorText, error, required, clearable, inline, showTodayButton, firstDayOfWeek, fullWidth, className, style, }: DatePickerProps): JSX_2.Element;
+declare function DatePicker({ value, defaultValue, onChange, format, locale, min, max, disabledDates, placeholder, disabled, readOnly, name, id, variant, size, fcolor, label, helperText, errorText, error, required, clearable, inline, showTodayButton, firstDayOfWeek, fullWidth, className, style, }: DatePickerProps): JSX_2.Element;
+export { DatePicker }
+export { DatePicker as MDatePicker }
 
-export declare interface DatePickerProps {
+declare interface DatePickerProps {
     value?: Date | string;
     defaultValue?: Date | string;
     onChange?: (date: Date | null) => void;
@@ -111,6 +510,7 @@ export declare interface DatePickerProps {
     id?: string;
     variant?: DatePickerVariant;
     size?: MineralSize;
+    fcolor?: MineralFontColor;
     label?: string;
     helperText?: string;
     errorText?: string;
@@ -124,20 +524,106 @@ export declare interface DatePickerProps {
     className?: string;
     style?: CSSProperties;
 }
+export { DatePickerProps }
+export { DatePickerProps as MDatePickerProps }
+
+declare type DatePickerVariant = 'outlined' | 'filled' | 'underlined';
+export { DatePickerVariant }
+export { DatePickerVariant as MDatePickerVariant }
+
+declare function DateRangePicker({ value, defaultValue, onChange, format, locale, min, max, disabledDates, placeholder, disabled, readOnly, name, id, variant, size, fcolor, label, helperText, errorText, error, required, clearable, inline, showTodayButton, presets, firstDayOfWeek, fullWidth, allowSameDay, className, style, }: DateRangePickerProps): JSX_2.Element;
+export { DateRangePicker }
+export { DateRangePicker as MDateRangePicker }
+
+declare interface DateRangePickerProps {
+    value?: DateRangeValue;
+    defaultValue?: DateRangeValue;
+    onChange?: (range: {
+        start: Date | null;
+        end: Date | null;
+    }) => void;
+    format?: string;
+    locale?: 'pl' | 'en';
+    min?: Date | string;
+    max?: Date | string;
+    disabledDates?: Date[] | ((date: Date) => boolean);
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    id?: string;
+    variant?: DateRangePickerVariant;
+    size?: MineralSize;
+    fcolor?: MineralFontColor;
+    label?: string;
+    helperText?: string;
+    errorText?: string;
+    error?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    inline?: boolean;
+    showTodayButton?: boolean;
+    presets?: boolean | DateRangePreset[];
+    firstDayOfWeek?: 0 | 1;
+    fullWidth?: boolean;
+    allowSameDay?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export { DateRangePickerProps }
+export { DateRangePickerProps as MDateRangePickerProps }
 
-export declare type DatePickerVariant = 'outlined' | 'filled' | 'underlined';
+declare type DateRangePickerVariant = 'outlined' | 'filled' | 'underlined';
+export { DateRangePickerVariant }
+export { DateRangePickerVariant as MDateRangePickerVariant }
+
+declare interface DateRangePreset {
+    label: string;
+    value: {
+        start: Date | string;
+        end: Date | string;
+    };
+}
+export { DateRangePreset }
+export { DateRangePreset as MDateRangePreset }
+
+declare interface DateRangeValue {
+    start: Date | string | null;
+    end: Date | string | null;
+}
+export { DateRangeValue }
+export { DateRangeValue as MDateRangeValue }
 
 export declare function daysInMonth(year: number, month: number): number;
 
-export declare interface FieldRegistration {
+export declare function detectCardBrand(value: string): CreditCardBrandDetails;
+
+declare function Divider({ className, style, ...rest }: DividerProps): JSX_2.Element;
+export { Divider }
+export { Divider as MDivider }
+
+declare interface DividerProps extends HTMLAttributes<HTMLHRElement> {
+    className?: string;
+    style?: CSSProperties;
+}
+export { DividerProps }
+export { DividerProps as MDividerProps }
+
+declare interface FieldRegistration {
     name: string;
     validate?: ValidatorFn[];
     required?: boolean;
 }
+export { FieldRegistration }
+export { FieldRegistration as MFieldRegistration }
 
 export declare function firstDayOfMonth(year: number, month: number): number;
 
-export declare function Form({ initialValues, onSubmit, onChange, validationMode, children, className, style, noValidate, }: FormProps): JSX_2.Element;
+declare function Form({ initialValues, onSubmit, onChange, validationMode, children, className, style, noValidate, }: FormProps): JSX_2.Element;
+export { Form }
+export { Form as MForm }
+
+export declare function formatCardNumber(value: string): string;
 
 export declare function formatCurrency(value: string, options?: CurrencyFormatOptions): string;
 
@@ -149,9 +635,11 @@ export declare function formatNIP(value: string): string;
 
 export declare function formatPhone(value: string, options?: PhoneFormatOptions): string;
 
+export declare function formatPostCode(value: string, countryCode?: string): string;
+
 export declare function formatTime(hours: number, minutes: number, seconds?: number, showSeconds?: boolean): string;
 
-export declare interface FormContextValue {
+declare interface FormContextValue {
     values: Record<string, unknown>;
     errors: Record<string, string>;
     touched: Record<string, boolean>;
@@ -165,21 +653,27 @@ export declare interface FormContextValue {
     resetForm: () => void;
     isSubmitting: boolean;
 }
+export { FormContextValue }
+export { FormContextValue as MFormContextValue }
 
-export declare interface FormFieldProps {
+declare interface FormFieldProps {
     name: string;
     validate?: ValidatorFn[];
     required?: boolean;
     children: ReactNode;
 }
+export { FormFieldProps }
+export { FormFieldProps as MFormFieldProps }
 
-export declare interface FormHelpers {
+declare interface FormHelpers {
     setSubmitting: (isSubmitting: boolean) => void;
     resetForm: () => void;
     setFieldError: (name: string, error: string) => void;
 }
+export { FormHelpers }
+export { FormHelpers as MFormHelpers }
 
-export declare interface FormProps {
+declare interface FormProps {
     initialValues?: Record<string, unknown>;
     onSubmit?: (values: Record<string, unknown>, helpers: FormHelpers) => void | Promise<void>;
     onChange?: (values: Record<string, unknown>) => void;
@@ -189,16 +683,357 @@ export declare interface FormProps {
     style?: CSSProperties;
     noValidate?: boolean;
 }
+export { FormProps }
+export { FormProps as MFormProps }
 
 export declare function getDayNames(locale?: 'pl' | 'en'): string[];
 
 export declare function getMonthNames(locale?: 'pl' | 'en'): string[];
 
-export declare const Input: ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>;
+export declare function getPostCodeRule(countryCode?: string): PostCodeRule;
 
-export declare const InputCurrency: ForwardRefExoticComponent<InputCurrencyProps & RefAttributes<HTMLInputElement>>;
+export declare function Grid({ columns, gap, minItemWidth, className, style, children, ...rest }: GridProps): JSX_2.Element;
 
-export declare interface InputCurrencyProps extends Omit<InputProps, 'type'> {
+export declare type GridColumns = (typeof gridColumnValues)[number];
+
+declare const gridColumnValues: readonly [1, 2, 3, 4];
+
+export declare interface GridProps extends HTMLAttributes<HTMLDivElement> {
+    columns?: GridColumns;
+    gap?: StackGap;
+    minItemWidth?: string;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+
+declare function Heading({ level, color, fcolor, className, children, ...rest }: HeadingProps): DetailedReactHTMLElement<    {
+onSelect?: ReactEventHandler<HTMLHeadingElement> | undefined;
+slot?: string | undefined | undefined;
+style?: CSSProperties | undefined;
+title?: string | undefined | undefined;
+hidden?: boolean | undefined | undefined;
+content?: string | undefined | undefined;
+role?: AriaRole | undefined;
+defaultChecked?: boolean | undefined | undefined;
+defaultValue?: string | number | readonly string[] | undefined;
+suppressContentEditableWarning?: boolean | undefined | undefined;
+suppressHydrationWarning?: boolean | undefined | undefined;
+accessKey?: string | undefined | undefined;
+autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+autoFocus?: boolean | undefined | undefined;
+contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
+contextMenu?: string | undefined | undefined;
+dir?: string | undefined | undefined;
+draggable?: (boolean | "true" | "false") | undefined;
+enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+id?: string | undefined | undefined;
+lang?: string | undefined | undefined;
+nonce?: string | undefined | undefined;
+spellCheck?: (boolean | "true" | "false") | undefined;
+tabIndex?: number | undefined | undefined;
+translate?: "yes" | "no" | undefined | undefined;
+radioGroup?: string | undefined | undefined;
+about?: string | undefined | undefined;
+datatype?: string | undefined | undefined;
+inlist?: any;
+prefix?: string | undefined | undefined;
+property?: string | undefined | undefined;
+rel?: string | undefined | undefined;
+resource?: string | undefined | undefined;
+rev?: string | undefined | undefined;
+typeof?: string | undefined | undefined;
+vocab?: string | undefined | undefined;
+autoCorrect?: string | undefined | undefined;
+autoSave?: string | undefined | undefined;
+itemProp?: string | undefined | undefined;
+itemScope?: boolean | undefined | undefined;
+itemType?: string | undefined | undefined;
+itemID?: string | undefined | undefined;
+itemRef?: string | undefined | undefined;
+results?: number | undefined | undefined;
+security?: string | undefined | undefined;
+unselectable?: "on" | "off" | undefined | undefined;
+inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+is?: string | undefined | undefined;
+exportparts?: string | undefined | undefined;
+part?: string | undefined | undefined;
+"aria-activedescendant"?: string | undefined | undefined;
+"aria-atomic"?: (boolean | "true" | "false") | undefined;
+"aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+"aria-braillelabel"?: string | undefined | undefined;
+"aria-brailleroledescription"?: string | undefined | undefined;
+"aria-busy"?: (boolean | "true" | "false") | undefined;
+"aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+"aria-colcount"?: number | undefined | undefined;
+"aria-colindex"?: number | undefined | undefined;
+"aria-colindextext"?: string | undefined | undefined;
+"aria-colspan"?: number | undefined | undefined;
+"aria-controls"?: string | undefined | undefined;
+"aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+"aria-describedby"?: string | undefined | undefined;
+"aria-description"?: string | undefined | undefined;
+"aria-details"?: string | undefined | undefined;
+"aria-disabled"?: (boolean | "true" | "false") | undefined;
+"aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+"aria-errormessage"?: string | undefined | undefined;
+"aria-expanded"?: (boolean | "true" | "false") | undefined;
+"aria-flowto"?: string | undefined | undefined;
+"aria-grabbed"?: (boolean | "true" | "false") | undefined;
+"aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+"aria-hidden"?: (boolean | "true" | "false") | undefined;
+"aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+"aria-keyshortcuts"?: string | undefined | undefined;
+"aria-label"?: string | undefined | undefined;
+"aria-labelledby"?: string | undefined | undefined;
+"aria-level"?: number | undefined | undefined;
+"aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+"aria-modal"?: (boolean | "true" | "false") | undefined;
+"aria-multiline"?: (boolean | "true" | "false") | undefined;
+"aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+"aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+"aria-owns"?: string | undefined | undefined;
+"aria-placeholder"?: string | undefined | undefined;
+"aria-posinset"?: number | undefined | undefined;
+"aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+"aria-readonly"?: (boolean | "true" | "false") | undefined;
+"aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+"aria-required"?: (boolean | "true" | "false") | undefined;
+"aria-roledescription"?: string | undefined | undefined;
+"aria-rowcount"?: number | undefined | undefined;
+"aria-rowindex"?: number | undefined | undefined;
+"aria-rowindextext"?: string | undefined | undefined;
+"aria-rowspan"?: number | undefined | undefined;
+"aria-selected"?: (boolean | "true" | "false") | undefined;
+"aria-setsize"?: number | undefined | undefined;
+"aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+"aria-valuemax"?: number | undefined | undefined;
+"aria-valuemin"?: number | undefined | undefined;
+"aria-valuenow"?: number | undefined | undefined;
+"aria-valuetext"?: string | undefined | undefined;
+dangerouslySetInnerHTML?: {
+__html: string | TrustedHTML;
+} | undefined | undefined;
+onCopy?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onCopyCapture?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onCut?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onCutCapture?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onPaste?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onPasteCapture?: ClipboardEventHandler<HTMLHeadingElement> | undefined;
+onCompositionEnd?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onCompositionEndCapture?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onCompositionStart?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onCompositionStartCapture?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onCompositionUpdate?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onCompositionUpdateCapture?: CompositionEventHandler<HTMLHeadingElement> | undefined;
+onFocus?: FocusEventHandler<HTMLHeadingElement> | undefined;
+onFocusCapture?: FocusEventHandler<HTMLHeadingElement> | undefined;
+onBlur?: FocusEventHandler<HTMLHeadingElement> | undefined;
+onBlurCapture?: FocusEventHandler<HTMLHeadingElement> | undefined;
+onChange?: FormEventHandler<HTMLHeadingElement> | undefined;
+onChangeCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onBeforeInput?: InputEventHandler<HTMLHeadingElement> | undefined;
+onBeforeInputCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onInput?: FormEventHandler<HTMLHeadingElement> | undefined;
+onInputCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onReset?: FormEventHandler<HTMLHeadingElement> | undefined;
+onResetCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onSubmit?: FormEventHandler<HTMLHeadingElement> | undefined;
+onSubmitCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onInvalid?: FormEventHandler<HTMLHeadingElement> | undefined;
+onInvalidCapture?: FormEventHandler<HTMLHeadingElement> | undefined;
+onLoad?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onError?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onErrorCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onKeyDown?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onKeyDownCapture?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onKeyPress?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onKeyPressCapture?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onKeyUp?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onKeyUpCapture?: KeyboardEventHandler<HTMLHeadingElement> | undefined;
+onAbort?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onAbortCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onCanPlay?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onCanPlayCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onCanPlayThrough?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onCanPlayThroughCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onDurationChange?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onDurationChangeCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEmptied?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEmptiedCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEncrypted?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEncryptedCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEnded?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onEndedCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadedData?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadedDataCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadedMetadata?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadedMetadataCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadStart?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onLoadStartCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPause?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPauseCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPlay?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPlayCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPlaying?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onPlayingCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onProgress?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onProgressCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onRateChange?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onRateChangeCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSeeked?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSeekedCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSeeking?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSeekingCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onStalled?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onStalledCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSuspend?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onSuspendCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onTimeUpdate?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onTimeUpdateCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onVolumeChange?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onVolumeChangeCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onWaiting?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onWaitingCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onAuxClick?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onAuxClickCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onClick?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onClickCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onContextMenu?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onContextMenuCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onDoubleClick?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onDoubleClickCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onDrag?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragEnd?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragEndCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragEnter?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragEnterCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragExit?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragExitCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragLeave?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragLeaveCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragOver?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragOverCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragStart?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDragStartCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDrop?: DragEventHandler<HTMLHeadingElement> | undefined;
+onDropCapture?: DragEventHandler<HTMLHeadingElement> | undefined;
+onMouseDown?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseDownCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseEnter?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseLeave?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseMove?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseMoveCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseOut?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseOutCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseOver?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseOverCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseUp?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onMouseUpCapture?: MouseEventHandler<HTMLHeadingElement> | undefined;
+onSelectCapture?: ReactEventHandler<HTMLHeadingElement> | undefined;
+onTouchCancel?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchCancelCapture?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchEnd?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchEndCapture?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchMove?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchMoveCapture?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchStart?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onTouchStartCapture?: TouchEventHandler<HTMLHeadingElement> | undefined;
+onPointerDown?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerDownCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerMove?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerMoveCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerUp?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerUpCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerCancel?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerCancelCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerEnter?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerLeave?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerOver?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerOverCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerOut?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onPointerOutCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onGotPointerCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onGotPointerCaptureCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onLostPointerCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onLostPointerCaptureCapture?: PointerEventHandler<HTMLHeadingElement> | undefined;
+onScroll?: UIEventHandler<HTMLHeadingElement> | undefined;
+onScrollCapture?: UIEventHandler<HTMLHeadingElement> | undefined;
+onWheel?: WheelEventHandler<HTMLHeadingElement> | undefined;
+onWheelCapture?: WheelEventHandler<HTMLHeadingElement> | undefined;
+onAnimationStart?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onAnimationStartCapture?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onAnimationEnd?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onAnimationEndCapture?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onAnimationIteration?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onAnimationIterationCapture?: AnimationEventHandler<HTMLHeadingElement> | undefined;
+onTransitionEnd?: TransitionEventHandler<HTMLHeadingElement> | undefined;
+onTransitionEndCapture?: TransitionEventHandler<HTMLHeadingElement> | undefined;
+className: string;
+}, HTMLElement>;
+export { Heading }
+export { Heading as MHeading }
+
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+declare interface HeadingProps extends Omit<HTMLAttributes<HTMLHeadingElement>, 'color'> {
+    level?: HeadingLevel;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+export { HeadingProps }
+export { HeadingProps as MHeadingProps }
+
+declare function Inline({ gap, align, justify, wrap, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: InlineProps): JSX_2.Element;
+export { Inline }
+export { Inline as MInline }
+
+export declare type InlineAlign = 'start' | 'center' | 'end' | 'stretch';
+
+export declare type InlineJustify = 'start' | 'center' | 'end' | 'between';
+
+declare interface InlineProps extends HTMLAttributes<HTMLDivElement>, LayoutUtilityProps {
+    gap?: StackGap;
+    align?: InlineAlign;
+    justify?: InlineJustify;
+    wrap?: InlineWrap;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export { InlineProps }
+export { InlineProps as MInlineProps }
+
+export declare type InlineWrap = 'wrap' | 'nowrap';
+
+declare const Input: ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>;
+export { Input }
+export { Input as MInput }
+
+declare const InputCreditCard: ForwardRefExoticComponent<InputCreditCardProps & RefAttributes<HTMLInputElement>>;
+export { InputCreditCard }
+export { InputCreditCard as MInputCreditCard }
+
+declare interface InputCreditCardProps extends Omit<InputProps, 'type' | 'inputMode' | 'startIcon' | 'endIcon'> {
+    validateOnBlur?: boolean;
+    validateOnChange?: boolean;
+    showBrandIcon?: boolean;
+    showValidIcon?: boolean;
+    onValidationChange?: (result: ValidationResult) => void;
+    onCardBrandChange?: (brand: CreditCardBrand) => void;
+    onValueChange?: (rawValue: string, formattedValue: string, brand: CreditCardBrand) => void;
+}
+export { InputCreditCardProps }
+export { InputCreditCardProps as MInputCreditCardProps }
+
+declare const InputCurrency: ForwardRefExoticComponent<InputCurrencyProps & RefAttributes<HTMLInputElement>>;
+export { InputCurrency }
+export { InputCurrency as MInputCurrency }
+
+declare interface InputCurrencyProps extends Omit<InputProps, 'type'> {
     currency?: string;
     currencySymbol?: string;
     currencyPosition?: 'start' | 'end';
@@ -210,19 +1045,52 @@ export declare interface InputCurrencyProps extends Omit<InputProps, 'type'> {
     allowNegative?: boolean;
     onValueChange?: (value: number | null) => void;
 }
+export { InputCurrencyProps }
+export { InputCurrencyProps as MInputCurrencyProps }
 
-export declare const InputEmail: ForwardRefExoticComponent<InputEmailProps & RefAttributes<HTMLInputElement>>;
+declare const InputEmail: ForwardRefExoticComponent<InputEmailProps & RefAttributes<HTMLInputElement>>;
+export { InputEmail }
+export { InputEmail as MInputEmail }
 
-export declare interface InputEmailProps extends Omit<InputProps, 'type'> {
+declare interface InputEmailProps extends Omit<InputProps, 'type'> {
     validateOnBlur?: boolean;
     validateOnChange?: boolean;
     showValidIcon?: boolean;
     onValidationChange?: (result: ValidationResult) => void;
 }
+export { InputEmailProps }
+export { InputEmailProps as MInputEmailProps }
+
+declare const InputGroup: ForwardRefExoticComponent<InputGroupProps & RefAttributes<HTMLInputElement>>;
+export { InputGroup }
+export { InputGroup as MInputGroup }
+
+declare interface InputGroupAddon {
+    type: 'text' | 'icon' | 'button' | 'checkbox';
+    content: ReactNode;
+    onClick?: () => void;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+export { InputGroupAddon }
+export { InputGroupAddon as MInputGroupAddon }
+
+declare interface InputGroupProps extends Omit<InputProps, 'startIcon' | 'endIcon' | 'rounded'> {
+    prepend?: InputGroupSlot | InputGroupSlot[];
+    append?: InputGroupSlot | InputGroupSlot[];
+}
+export { InputGroupProps }
+export { InputGroupProps as MInputGroupProps }
 
-export declare const InputIBAN: ForwardRefExoticComponent<InputIBANProps & RefAttributes<HTMLInputElement>>;
+declare type InputGroupSlot = InputGroupAddon | ReactNode;
+export { InputGroupSlot }
+export { InputGroupSlot as MInputGroupSlot }
 
-export declare interface InputIBANProps extends Omit<InputProps, 'type'> {
+declare const InputIBAN: ForwardRefExoticComponent<InputIBANProps & RefAttributes<HTMLInputElement>>;
+export { InputIBAN }
+export { InputIBAN as MInputIBAN }
+
+declare interface InputIBANProps extends Omit<InputProps, 'type'> {
     countryCode?: string;
     formatOnChange?: boolean;
     validateOnBlur?: boolean;
@@ -230,10 +1098,14 @@ export declare interface InputIBANProps extends Omit<InputProps, 'type'> {
     onValidationChange?: (result: ValidationResult) => void;
     onValueChange?: (rawValue: string, formattedValue: string) => void;
 }
+export { InputIBANProps }
+export { InputIBANProps as MInputIBANProps }
 
-export declare const InputName: ForwardRefExoticComponent<InputNameProps & RefAttributes<HTMLInputElement>>;
+declare const InputName: ForwardRefExoticComponent<InputNameProps & RefAttributes<HTMLInputElement>>;
+export { InputName }
+export { InputName as MInputName }
 
-export declare interface InputNameProps extends Omit<InputProps, 'type'> {
+declare interface InputNameProps extends Omit<InputProps, 'type'> {
     autoCapitalize?: boolean;
     allowNumbers?: boolean;
     allowSpecialChars?: boolean;
@@ -241,10 +1113,14 @@ export declare interface InputNameProps extends Omit<InputProps, 'type'> {
     validateOnBlur?: boolean;
     onValidationChange?: (result: ValidationResult) => void;
 }
+export { InputNameProps }
+export { InputNameProps as MInputNameProps }
 
-export declare const InputNumber: ForwardRefExoticComponent<InputNumberProps & RefAttributes<HTMLInputElement>>;
+declare const InputNumber: ForwardRefExoticComponent<InputNumberProps & RefAttributes<HTMLInputElement>>;
+export { InputNumber }
+export { InputNumber as MInputNumber }
 
-export declare interface InputNumberProps extends Omit<InputProps, 'type'> {
+declare interface InputNumberProps extends Omit<InputProps, 'type'> {
     min?: number;
     max?: number;
     step?: number;
@@ -253,18 +1129,26 @@ export declare interface InputNumberProps extends Omit<InputProps, 'type'> {
     allowNegative?: boolean;
     onValueChange?: (value: number | null) => void;
 }
+export { InputNumberProps }
+export { InputNumberProps as MInputNumberProps }
 
-export declare const InputPassword: ForwardRefExoticComponent<InputPasswordProps & RefAttributes<HTMLInputElement>>;
+declare const InputPassword: ForwardRefExoticComponent<InputPasswordProps & RefAttributes<HTMLInputElement>>;
+export { InputPassword }
+export { InputPassword as MInputPassword }
 
-export declare interface InputPasswordProps extends Omit<InputProps, 'type' | 'endIcon'> {
+declare interface InputPasswordProps extends Omit<InputProps, 'type' | 'endIcon'> {
     showToggle?: boolean;
     showStrength?: boolean;
     onStrengthChange?: (strength: PasswordStrength) => void;
 }
+export { InputPasswordProps }
+export { InputPasswordProps as MInputPasswordProps }
 
-export declare const InputPhone: ForwardRefExoticComponent<InputPhoneProps & RefAttributes<HTMLInputElement>>;
+declare const InputPhone: ForwardRefExoticComponent<InputPhoneProps & RefAttributes<HTMLInputElement>>;
+export { InputPhone }
+export { InputPhone as MInputPhone }
 
-export declare interface InputPhoneProps extends Omit<InputProps, 'type'> {
+declare interface InputPhoneProps extends Omit<InputProps, 'type'> {
     countryCode?: string;
     showCountryCode?: boolean;
     formatOnChange?: boolean;
@@ -272,8 +1156,27 @@ export declare interface InputPhoneProps extends Omit<InputProps, 'type'> {
     onValidationChange?: (result: ValidationResult) => void;
     onValueChange?: (rawValue: string, formattedValue: string) => void;
 }
+export { InputPhoneProps }
+export { InputPhoneProps as MInputPhoneProps }
+
+declare const InputPostCode: ForwardRefExoticComponent<InputPostCodeProps & RefAttributes<HTMLInputElement>>;
+export { InputPostCode }
+export { InputPostCode as MInputPostCode }
+
+declare interface InputPostCodeProps extends Omit<InputGroupProps, 'prepend' | 'type' | 'inputMode'> {
+    country?: string;
+    defaultCountry?: string;
+    selectableCountry?: boolean;
+    validateOnBlur?: boolean;
+    validateOnChange?: boolean;
+    onCountryChange?: (countryCode: string) => void;
+    onValidationChange?: (result: ValidationResult) => void;
+    onValueChange?: (rawValue: string, formattedValue: string, countryCode: string) => void;
+}
+export { InputPostCodeProps }
+export { InputPostCodeProps as MInputPostCodeProps }
 
-export declare interface InputProps {
+declare interface InputProps {
     type?: 'text' | 'password' | 'email' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'datetime-local' | 'time';
     value?: string | number;
     defaultValue?: string | number;
@@ -289,6 +1192,7 @@ export declare interface InputProps {
     variant?: InputVariant;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     fullWidth?: boolean;
     rounded?: boolean;
     label?: string;
@@ -307,22 +1211,32 @@ export declare interface InputProps {
     onKeyDown?: (e: KeyboardEvent_2<HTMLInputElement>) => void;
     onClear?: () => void;
     loading?: boolean;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
     className?: string;
     style?: CSSProperties;
     inputClassName?: string;
     labelClassName?: string;
 }
+export { InputProps }
+export { InputProps as MInputProps }
 
-export declare const InputSearch: ForwardRefExoticComponent<InputSearchProps & RefAttributes<HTMLInputElement>>;
+declare const InputSearch: ForwardRefExoticComponent<InputSearchProps & RefAttributes<HTMLInputElement>>;
+export { InputSearch }
+export { InputSearch as MInputSearch }
 
-export declare interface InputSearchProps extends Omit<InputProps, 'type' | 'startIcon'> {
+declare interface InputSearchProps extends Omit<InputProps, 'type' | 'startIcon'> {
     debounceMs?: number;
     onSearch?: (value: string) => void;
 }
+export { InputSearchProps }
+export { InputSearchProps as MInputSearchProps }
 
-export declare const InputTaxId: ForwardRefExoticComponent<InputTaxIdProps & RefAttributes<HTMLInputElement>>;
+declare const InputTaxId: ForwardRefExoticComponent<InputTaxIdProps & RefAttributes<HTMLInputElement>>;
+export { InputTaxId }
+export { InputTaxId as MInputTaxId }
 
-export declare interface InputTaxIdProps extends Omit<InputProps, 'type'> {
+declare interface InputTaxIdProps extends Omit<InputProps, 'type'> {
     taxIdType: TaxIdType;
     formatOnChange?: boolean;
     validateOnBlur?: boolean;
@@ -330,47 +1244,310 @@ export declare interface InputTaxIdProps extends Omit<InputProps, 'type'> {
     onValidationChange?: (result: ValidationResult) => void;
     onValueChange?: (rawValue: string) => void;
 }
+export { InputTaxIdProps }
+export { InputTaxIdProps as MInputTaxIdProps }
 
-export declare type InputVariant = 'outlined' | 'filled' | 'underlined';
+declare type InputVariant = 'outlined' | 'filled' | 'underlined';
+export { InputVariant }
+export { InputVariant as MInputVariant }
 
 export declare function isDateInRange(date: Date, min?: Date | null, max?: Date | null): boolean;
 
 export declare function isSameDay(a: Date, b: Date): boolean;
 
-export declare type MineralColor = 'primary' | 'success' | 'error' | 'warning' | 'info';
+declare interface LayoutUtilityProps {
+    spacing?: MineralUtilityScale;
+    padding?: MineralUtilityScale;
+    fsize?: string | number;
+    fcolor?: MineralFontColor;
+    mt?: MineralUtilityScale;
+    mb?: MineralUtilityScale;
+    ml?: MineralUtilityScale;
+    mr?: MineralUtilityScale;
+    mx?: MineralUtilityScale;
+    my?: MineralUtilityScale;
+    pt?: MineralUtilityScale;
+    pb?: MineralUtilityScale;
+    pl?: MineralUtilityScale;
+    pr?: MineralUtilityScale;
+    px?: MineralUtilityScale;
+    py?: MineralUtilityScale;
+    fullWidth?: boolean;
+}
+
+declare function List({ ordered, color, fcolor, className, children, ...rest }: ListProps): JSX_2.Element;
+export { List }
+export { List as MList }
+
+declare function ListItem({ className, children, ...rest }: HTMLAttributes<HTMLLIElement>): JSX_2.Element;
+export { ListItem }
+export { ListItem as MListItem }
+
+declare interface ListProps extends Omit<HTMLAttributes<HTMLUListElement>, 'color'> {
+    ordered?: boolean;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+export { ListProps }
+export { ListProps as MListProps }
+
+declare function Loader({ color, size, label, center, minHeight, className, style, ...rest }: LoaderProps): JSX_2.Element;
+export { Loader }
+export { Loader as MLoader }
+
+declare interface LoaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    color?: MineralColor;
+    size?: MineralSize | number;
+    label?: string;
+    center?: boolean;
+    minHeight?: string | number;
+}
+export { LoaderProps }
+export { LoaderProps as MLoaderProps }
+
+export declare function MFooter({ container, padded, bordered, tone, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: MFooterProps): JSX_2.Element;
+
+export declare interface MFooterProps extends HTMLAttributes<HTMLElement>, LayoutUtilityProps {
+    container?: ContainerSize;
+    padded?: boolean;
+    bordered?: boolean;
+    tone?: MHeaderTone;
+    children?: ReactNode;
+}
+
+export declare function MGrid({ type, gap, span, sm, md, lg, xl, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: MGridProps): JSX_2.Element;
+
+export declare type MGridColumns = (typeof mGridColumnValues)[number];
+
+declare const mGridColumnValues: readonly [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+
+export declare function MGridItem({ span, sm, md, lg, xl, ...rest }: MGridItemProps): JSX_2.Element;
+
+export declare interface MGridItemProps extends Omit<MGridProps, 'type' | 'gap'>, Pick<MGridProps, 'span' | 'sm' | 'md' | 'lg' | 'xl'> {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+
+export declare interface MGridProps extends HTMLAttributes<HTMLDivElement>, LayoutUtilityProps {
+    type?: MGridType;
+    gap?: StackGap;
+    span?: MGridColumns;
+    sm?: MGridColumns;
+    md?: MGridColumns;
+    lg?: MGridColumns;
+    xl?: MGridColumns;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+
+export declare type MGridType = 'row' | 'col';
+
+export declare function MHeader({ container, padded, bordered, sticky, tone, fcolor, className, children, ...rest }: MHeaderProps): JSX_2.Element;
+
+export declare interface MHeaderProps extends HTMLAttributes<HTMLElement> {
+    container?: ContainerSize;
+    padded?: boolean;
+    bordered?: boolean;
+    sticky?: boolean;
+    tone?: MHeaderTone;
+    fcolor?: MineralFontColor;
+    children?: ReactNode;
+}
+
+export declare type MHeaderTone = 'default' | 'surface' | 'subtle';
+
+export declare type MineralClickEffect = 'none' | 'ripple';
+
+export declare type MineralColor = 'primary' | 'neutral' | 'success' | 'error' | 'warning' | 'info';
+
+export declare type MineralFontColor = 'default' | 'muted' | 'heading' | 'inverted' | 'inherit' | 'primary' | 'neutral' | 'success' | 'error' | 'warning' | 'info';
+
+export declare type MineralMode = 'dark' | 'light';
 
 export declare type MineralSize = 'sm' | 'md' | 'lg';
 
 export declare interface MineralTheme {
+    primaryRgb?: string;
     primary?: string;
     primaryDark?: string;
     primaryLight?: string;
+    neutralRgb?: string;
+    neutral?: string;
     dark?: string;
     darkLight?: string;
     surface?: string;
+    surfaceContrast?: string;
+    pageBg?: string;
+    pageText?: string;
     text?: string;
     textSecondary?: string;
     textHeading?: string;
     border?: string;
     borderHover?: string;
     borderFocus?: string;
+    successRgb?: string;
     success?: string;
+    errorRgb?: string;
     error?: string;
+    warningRgb?: string;
     warning?: string;
+    infoRgb?: string;
     info?: string;
     fontFamily?: string;
+    fontFamilySans?: string;
+    fontFamilyMono?: string;
+    fontFamilyHeading?: string;
+    fontColorDefault?: string;
+    fontColorMuted?: string;
+    fontColorHeading?: string;
+    fontColorInverted?: string;
+    fontColorPrimary?: string;
+    fontColorNeutral?: string;
+    fontColorSuccess?: string;
+    fontColorError?: string;
+    fontColorWarning?: string;
+    fontColorInfo?: string;
     radiusSm?: string;
     radiusMd?: string;
     radiusLg?: string;
 }
 
-export declare function MineralThemeProvider({ theme, children }: MineralThemeProviderProps): JSX_2.Element;
+declare function MineralThemeProvider({ theme, mode, scope, children }: MineralThemeProviderProps): JSX_2.Element;
+export { MineralThemeProvider as MThemeProvider }
+export { MineralThemeProvider }
 
 declare interface MineralThemeProviderProps {
-    theme: MineralTheme;
+    theme?: MineralTheme;
+    mode?: MineralMode;
+    scope?: MineralThemeScope;
     children: ReactNode;
 }
 
+export declare type MineralThemeScope = 'body' | 'wrapper';
+
+declare type MineralUtilityScale = (typeof mineralUtilityScaleValues)[number];
+
+declare const mineralUtilityScaleValues: readonly ["none", "xs", "sm", "md", "lg", "xl", "2xl"];
+
+export declare const MLink: ForwardRefExoticComponent<MLinkProps & RefAttributes<HTMLElement>>;
+
+export declare interface MLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    component?: ElementType;
+    to?: string;
+    tone?: MLinkTone;
+    underline?: MLinkUnderline;
+    fcolor?: MineralFontColor;
+    current?: boolean;
+    block?: boolean;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+
+export declare type MLinkTone = 'default' | 'muted' | 'accent' | 'inherit';
+
+export declare type MLinkUnderline = 'always' | 'hover' | 'none';
+
+export declare function MNavbar({ container, padded, bordered, sticky, tone, fcolor, justify, align, wrap, className, children, ...rest }: MNavbarProps): JSX_2.Element;
+
+export declare type MNavbarAlign = 'start' | 'center' | 'end' | 'stretch';
+
+export declare type MNavbarJustify = 'start' | 'center' | 'between' | 'end';
+
+export declare interface MNavbarProps extends HTMLAttributes<HTMLElement> {
+    container?: ContainerSize;
+    padded?: boolean;
+    bordered?: boolean;
+    sticky?: boolean;
+    tone?: MNavbarTone;
+    fcolor?: MineralFontColor;
+    justify?: MNavbarJustify;
+    align?: MNavbarAlign;
+    wrap?: boolean;
+    children?: ReactNode;
+}
+
+export declare type MNavbarTone = 'default' | 'surface' | 'subtle';
+
+export declare function MNavs({ items, orientation, gap, fcolor, wrap, className, children, ...rest }: MNavsProps): JSX_2.Element;
+
+export declare type MNavsGap = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+
+export declare interface MNavsItem extends Pick<MLinkProps, 'href' | 'to' | 'target' | 'rel' | 'title'> {
+    key?: string;
+    component?: ElementType;
+    label: ReactNode;
+    current?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+
+export declare type MNavsOrientation = 'horizontal' | 'vertical';
+
+export declare interface MNavsProps extends HTMLAttributes<HTMLElement> {
+    items?: MNavsItem[];
+    orientation?: MNavsOrientation;
+    gap?: MNavsGap;
+    fcolor?: MineralFontColor;
+    wrap?: boolean;
+    children?: ReactNode;
+}
+
+declare function Modal({ open, onClose, title, description, footer, size, closeOnBackdrop, closeOnEscape, className, children, ...rest }: ModalProps): JSX_2.Element | null;
+export { Modal as MModal }
+export { Modal }
+
+declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'color'> {
+    open: boolean;
+    onClose: () => void;
+    title?: ReactNode;
+    description?: ReactNode;
+    footer?: ReactNode;
+    size?: ModalSize;
+    closeOnBackdrop?: boolean;
+    closeOnEscape?: boolean;
+}
+export { ModalProps as MModalProps }
+export { ModalProps }
+
+declare type ModalSize = 'sm' | 'md' | 'lg' | 'xl';
+export { ModalSize as MModalSize }
+export { ModalSize }
+
+export declare function MTabs({ items, value, defaultValue, onValueChange, variant, orientation, size, fullWidth, fcolor, showPanels, panelClassName, clickEffect, rippleColor, className, ...rest }: MTabsProps): JSX_2.Element;
+
+export declare interface MTabsItem {
+    value: string;
+    label: ReactNode;
+    content?: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+
+declare type MTabsOrientation = 'horizontal' | 'vertical';
+
+export declare interface MTabsProps extends HTMLAttributes<HTMLDivElement> {
+    items: MTabsItem[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    variant?: MTabsVariant;
+    orientation?: MTabsOrientation;
+    size?: MTabsSize;
+    fullWidth?: boolean;
+    fcolor?: MineralFontColor;
+    showPanels?: boolean;
+    panelClassName?: string;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
+}
+
+export declare type MTabsSize = 'sm' | 'md' | 'lg';
+
+export declare type MTabsVariant = 'underline' | 'pills';
+
 export declare function parseCurrencyToNumber(formatted: string, thousandSeparator?: string, decimalSeparator?: string): number | null;
 
 export declare function parseDate(value: string, format?: string): Date | null;
@@ -381,18 +1558,24 @@ export declare function parseTime(value: string): {
     seconds: number;
 } | null;
 
-export declare type PasswordStrength = 'weak' | 'fair' | 'good' | 'strong';
+declare type PasswordStrength = 'weak' | 'fair' | 'good' | 'strong';
+export { PasswordStrength as MPasswordStrength }
+export { PasswordStrength }
 
 export declare interface PhoneFormatOptions {
     countryCode?: string;
     groupPattern?: number[];
 }
 
-export declare function Popover({ open, anchorRef, onClose, placement, matchWidth, offset, children, className, style, }: PopoverProps): JSX_2.Element | null;
+declare function Popover({ open, anchorRef, onClose, placement, matchWidth, offset, children, className, style, }: PopoverProps): JSX_2.Element | null;
+export { Popover as MPopover }
+export { Popover }
 
-export declare type PopoverPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+declare type PopoverPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+export { PopoverPlacement as MPopoverPlacement }
+export { PopoverPlacement }
 
-export declare interface PopoverProps {
+declare interface PopoverProps {
     open: boolean;
     anchorRef: RefObject<HTMLElement | null>;
     onClose: () => void;
@@ -403,19 +1586,49 @@ export declare interface PopoverProps {
     className?: string;
     style?: CSSProperties;
 }
+export { PopoverProps as MPopoverProps }
+export { PopoverProps }
 
-export declare function Portal({ children, container }: PortalProps): ReactPortal | null;
+declare function Portal({ children, container }: PortalProps): ReactPortal | null;
+export { Portal as MPortal }
+export { Portal }
 
-export declare interface PortalProps {
+declare interface PortalProps {
     children: ReactNode;
     container?: HTMLElement;
 }
+export { PortalProps as MPortalProps }
+export { PortalProps }
+
+export declare const postCodeCountries: {
+    value: string;
+    label: string;
+}[];
+
+export declare interface PostCodeRule {
+    countryCode: string;
+    label: string;
+    placeholder: string;
+    example: string;
+    inputMode: 'text' | 'numeric';
+    maxLength: number;
+    regex: RegExp;
+    sanitize: (value: string) => string;
+    format: (value: string) => string;
+    message: string;
+}
+
+export declare const postCodeRules: Record<string, PostCodeRule>;
 
-export declare const Radio: ForwardRefExoticComponent<RadioProps & RefAttributes<HTMLInputElement>>;
+declare const Radio: ForwardRefExoticComponent<RadioProps & RefAttributes<HTMLInputElement>>;
+export { Radio as MRadio }
+export { Radio }
 
-export declare function RadioGroup({ name, value, defaultValue, onChange, direction, children, disabled, size, color, error, errorText, label, className, style, }: RadioGroupProps): JSX_2.Element;
+declare function RadioGroup({ name, value, defaultValue, onChange, direction, children, disabled, size, color, fcolor, error, errorText, label, className, style, }: RadioGroupProps): JSX_2.Element;
+export { RadioGroup as MRadioGroup }
+export { RadioGroup }
 
-export declare interface RadioGroupProps {
+declare interface RadioGroupProps {
     name: string;
     value?: string;
     defaultValue?: string;
@@ -425,14 +1638,17 @@ export declare interface RadioGroupProps {
     disabled?: boolean;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     error?: boolean;
     errorText?: string;
     label?: string;
     className?: string;
     style?: CSSProperties;
 }
+export { RadioGroupProps as MRadioGroupProps }
+export { RadioGroupProps }
 
-export declare interface RadioProps {
+declare interface RadioProps {
     checked?: boolean;
     defaultChecked?: boolean;
     name?: string;
@@ -441,23 +1657,51 @@ export declare interface RadioProps {
     disabled?: boolean;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     label?: ReactNode;
     labelPosition?: 'right' | 'left';
     onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
     className?: string;
     style?: CSSProperties;
 }
+export { RadioProps as MRadioProps }
+export { RadioProps }
+
+declare function Section({ as, spacing, tone, className, style, children, ...rest }: SectionProps): JSX_2.Element;
+export { Section as MSection }
+export { Section }
+
+declare interface SectionProps extends HTMLAttributes<HTMLElement> {
+    as?: 'section' | 'div' | 'main' | 'header' | 'footer';
+    spacing?: SectionSpacing;
+    tone?: SectionTone;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export { SectionProps as MSectionProps }
+export { SectionProps }
+
+export declare type SectionSpacing = 'sm' | 'md' | 'lg' | 'xl';
+
+export declare type SectionTone = 'default' | 'subtle' | 'surface' | 'inverse';
 
-export declare function Select({ options, value, defaultValue, onChange, multiple, searchable, placeholder, disabled, name, id, variant, size, color, fullWidth, label, helperText, errorText, error, required, loading, clearable, maxHeight, noOptionsText, renderOption, renderValue, className, style, }: SelectProps): JSX_2.Element;
+declare function Select({ options, value, defaultValue, onChange, multiple, searchable, placeholder, disabled, name, id, variant, size, color, fcolor, fullWidth, label, helperText, errorText, error, required, loading, clearable, maxHeight, noOptionsText, renderOption, renderValue, className, style, }: SelectProps): JSX_2.Element;
+export { Select as MSelect }
+export { Select }
 
-export declare interface SelectOption {
+declare interface SelectOption {
     value: string;
     label: string;
     disabled?: boolean;
     group?: string;
 }
+export { SelectOption as MSelectOption }
+export { SelectOption }
 
-export declare interface SelectProps {
+declare interface SelectProps {
     options: SelectOption[];
     value?: string | string[];
     defaultValue?: string | string[];
@@ -471,6 +1715,7 @@ export declare interface SelectProps {
     variant?: SelectVariant;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     fullWidth?: boolean;
     label?: string;
     helperText?: string;
@@ -486,8 +1731,44 @@ export declare interface SelectProps {
     className?: string;
     style?: CSSProperties;
 }
+export { SelectProps as MSelectProps }
+export { SelectProps }
+
+declare type SelectVariant = 'outlined' | 'filled' | 'underlined';
+export { SelectVariant as MSelectVariant }
+export { SelectVariant }
+
+declare function Spinner({ color, size, label, className, style, ...rest }: SpinnerProps): JSX_2.Element;
+export { Spinner as MSpinner }
+export { Spinner }
+
+declare interface SpinnerProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    color?: MineralColor;
+    size?: MineralSize | number;
+    label?: string;
+}
+export { SpinnerProps as MSpinnerProps }
+export { SpinnerProps }
+
+declare function Stack({ gap, align, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: StackProps): JSX_2.Element;
+export { Stack as MStack }
+export { Stack }
+
+export declare type StackAlign = 'stretch' | 'start' | 'center' | 'end';
+
+export declare type StackGap = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+
+declare interface StackProps extends HTMLAttributes<HTMLDivElement>, LayoutUtilityProps {
+    gap?: StackGap;
+    align?: StackAlign;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export { StackProps as MStackProps }
+export { StackProps }
 
-export declare type SelectVariant = 'outlined' | 'filled' | 'underlined';
+export declare function stripCardNumber(value: string): string;
 
 export declare function stripNonAlphanumeric(value: string): string;
 
@@ -495,11 +1776,92 @@ export declare function stripNonDigits(value: string): string;
 
 export declare function stripTime(date: Date): Date;
 
-export declare type TaxIdType = 'NIP' | 'PESEL' | 'REGON';
+declare function Surface({ tone, outlined, padded, spacing, padding, fsize, fcolor, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, style, children, ...rest }: SurfaceProps): JSX_2.Element;
+export { Surface as MSurface }
+export { Surface }
 
-export declare const Textarea: ForwardRefExoticComponent<TextareaProps & RefAttributes<HTMLTextAreaElement>>;
+declare interface SurfaceProps extends HTMLAttributes<HTMLDivElement>, LayoutUtilityProps {
+    tone?: SurfaceTone;
+    outlined?: boolean;
+    padded?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export { SurfaceProps as MSurfaceProps }
+export { SurfaceProps }
+
+export declare type SurfaceTone = 'default' | 'subtle' | 'raised' | 'inverse';
+
+declare function Table({ className, children, ...rest }: TableProps): JSX_2.Element;
+export { Table as MTable }
+export { Table }
+
+declare function TableBody({ className, children, ...rest }: HTMLAttributes<HTMLTableSectionElement>): JSX_2.Element;
+export { TableBody as MTableBody }
+export { TableBody }
+
+declare function TableCell({ className, children, ...rest }: TableCellProps): JSX_2.Element;
+export { TableCell as MTableCell }
+export { TableCell }
+
+declare interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+}
+export { TableCellProps as MTableCellProps }
+export { TableCellProps }
+
+declare function TableHead({ className, children, ...rest }: HTMLAttributes<HTMLTableSectionElement>): JSX_2.Element;
+export { TableHead as MTableHead }
+export { TableHead }
+
+declare function TableHeadCell({ className, children, ...rest }: TableHeadCellProps): JSX_2.Element;
+export { TableHeadCell as MTableHeadCell }
+export { TableHeadCell }
+
+declare interface TableHeadCellProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+}
+export { TableHeadCellProps as MTableHeadCellProps }
+export { TableHeadCellProps }
+
+declare interface TableProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+export { TableProps as MTableProps }
+export { TableProps }
+
+declare function TableRoot({ className, children, ...rest }: TableRootProps): JSX_2.Element;
+export { TableRoot as MTableRoot }
+export { TableRoot }
+
+declare interface TableRootProps extends TableHTMLAttributes<HTMLTableElement> {
+    children?: ReactNode;
+}
+export { TableRootProps as MTableRootProps }
+export { TableRootProps }
+
+declare function TableRow({ className, children, ...rest }: HTMLAttributes<HTMLTableRowElement>): JSX_2.Element;
+export { TableRow as MTableRow }
+export { TableRow }
 
-export declare interface TextareaProps {
+declare type TaxIdType = 'NIP' | 'PESEL' | 'REGON';
+export { TaxIdType as MTaxIdType }
+export { TaxIdType }
+
+declare function Text_2({ as, tone, size, align, color, fcolor, weight, spacing, padding, fsize, mt, mb, ml, mr, mx, my, pt, pb, pl, pr, px, py, fullWidth, className, children, ...rest }: TextProps): JSX_2.Element;
+export { Text_2 as MText }
+export { Text_2 as Text }
+
+declare type TextAlign = 'left' | 'center' | 'right' | 'justify';
+export { TextAlign as MTextAlign }
+export { TextAlign }
+
+declare const Textarea: ForwardRefExoticComponent<TextareaProps & RefAttributes<HTMLTextAreaElement>>;
+export { Textarea as MTextarea }
+export { Textarea }
+
+declare interface TextareaProps {
     value?: string;
     defaultValue?: string;
     name?: string;
@@ -516,6 +1878,7 @@ export declare interface TextareaProps {
     variant?: TextareaVariant;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     fullWidth?: boolean;
     label?: string;
     helperText?: string;
@@ -533,12 +1896,40 @@ export declare interface TextareaProps {
     textareaClassName?: string;
     labelClassName?: string;
 }
+export { TextareaProps as MTextareaProps }
+export { TextareaProps }
+
+declare type TextareaVariant = 'outlined' | 'filled' | 'underlined';
+export { TextareaVariant as MTextareaVariant }
+export { TextareaVariant }
+
+declare interface TextProps extends Omit<HTMLAttributes<HTMLElement>, 'color'>, LayoutUtilityProps {
+    as?: 'p' | 'span' | 'div' | 'strong' | 'em';
+    tone?: TextTone;
+    size?: TextSize;
+    align?: TextAlign;
+    color?: MineralColor;
+    fcolor?: MineralFontColor;
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    children?: ReactNode;
+}
+export { TextProps as MTextProps }
+export { TextProps }
+
+export declare type TextSize = 'sm' | 'md' | 'lg';
 
-export declare type TextareaVariant = 'outlined' | 'filled' | 'underlined';
+export declare type TextTone = 'default' | 'muted' | 'accent' | 'success' | 'danger';
+
+declare interface ThemeContextValue {
+    theme: MineralTheme;
+    mode: MineralMode;
+}
 
-export declare function TimePicker({ value, defaultValue, onChange, format, showSeconds, minuteStep, min, max, placeholder, disabled, readOnly, name, id, variant, size, label, helperText, errorText, error, required, clearable, fullWidth, className, style, }: TimePickerProps): JSX_2.Element;
+declare function TimePicker({ value, defaultValue, onChange, format, showSeconds, minuteStep, min, max, placeholder, disabled, readOnly, name, id, variant, size, fcolor, label, helperText, errorText, error, required, clearable, fullWidth, className, style, }: TimePickerProps): JSX_2.Element;
+export { TimePicker as MTimePicker }
+export { TimePicker }
 
-export declare interface TimePickerProps {
+declare interface TimePickerProps {
     value?: string;
     defaultValue?: string;
     onChange?: (time: string) => void;
@@ -554,6 +1945,7 @@ export declare interface TimePickerProps {
     id?: string;
     variant?: TimePickerVariant;
     size?: MineralSize;
+    fcolor?: MineralFontColor;
     label?: string;
     helperText?: string;
     errorText?: string;
@@ -564,12 +1956,18 @@ export declare interface TimePickerProps {
     className?: string;
     style?: CSSProperties;
 }
+export { TimePickerProps as MTimePickerProps }
+export { TimePickerProps }
 
-export declare type TimePickerVariant = 'outlined' | 'filled' | 'underlined';
+declare type TimePickerVariant = 'outlined' | 'filled' | 'underlined';
+export { TimePickerVariant as MTimePickerVariant }
+export { TimePickerVariant }
 
-export declare const Toggle: ForwardRefExoticComponent<ToggleProps & RefAttributes<HTMLInputElement>>;
+declare const Toggle: ForwardRefExoticComponent<ToggleProps & RefAttributes<HTMLInputElement>>;
+export { Toggle as MToggle }
+export { Toggle }
 
-export declare interface ToggleProps {
+declare interface ToggleProps {
     checked?: boolean;
     defaultChecked?: boolean;
     name?: string;
@@ -577,16 +1975,23 @@ export declare interface ToggleProps {
     disabled?: boolean;
     size?: MineralSize;
     color?: MineralColor;
+    fcolor?: MineralFontColor;
     label?: ReactNode;
     labelPosition?: 'right' | 'left';
     onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+    clickEffect?: MineralClickEffect;
+    rippleColor?: string;
     className?: string;
     style?: CSSProperties;
 }
+export { ToggleProps as MToggleProps }
+export { ToggleProps }
 
 export declare function unformatIBAN(value: string): string;
 
-export declare function useClickOutside(ref: RefObject<HTMLElement | null>, handler: () => void): void;
+declare function useClickOutside(ref: RefObject<HTMLElement | null>, handler: () => void): void;
+export { useClickOutside }
+export { useClickOutside as useOutsideClick }
 
 export declare function useDebounce<T>(value: T, delay: number): T;
 
@@ -596,35 +2001,65 @@ export declare function useFormContext(): FormContextValue | null;
 
 export declare function useFormField(name: string, options?: UseFormFieldOptions): UseFormFieldReturn;
 
-export declare interface UseFormFieldOptions {
+declare interface UseFormFieldOptions {
     validate?: ValidatorFn[];
     required?: boolean;
 }
+export { UseFormFieldOptions as MUseFormFieldOptions }
+export { UseFormFieldOptions }
 
-export declare interface UseFormFieldReturn {
+declare interface UseFormFieldReturn {
     value: unknown;
     error: string | undefined;
     touched: boolean;
     onChange: (value: unknown) => void;
     onBlur: () => void;
 }
+export { UseFormFieldReturn as MUseFormFieldReturn }
+export { UseFormFieldReturn }
+
+declare function useInteractionEffect<T extends HTMLElement = HTMLElement>({ effect, disabled, centered, color, }?: UseInteractionEffectOptions): UseInteractionEffectResult<T>;
+export { useInteractionEffect as useClickEffect }
+export { useInteractionEffect }
+
+export declare interface UseInteractionEffectOptions {
+    effect?: MineralClickEffect;
+    disabled?: boolean;
+    centered?: boolean;
+    color?: string;
+}
 
-export declare function useKeyboardNav({ itemCount, onSelect, onClose, isOpen, loop, }: UseKeyboardNavOptions): {
+export declare interface UseInteractionEffectResult<T extends HTMLElement> {
+    effectClassName?: string;
+    effectLayer: ReactElement | null;
+    handlePointerDown: (event: PointerEvent_2<T>) => void;
+    triggerEffect: (target: T | null) => void;
+}
+
+declare function useKeyboardNav({ itemCount, onSelect, onClose, isOpen, loop }: UseKeyboardNavOptions): {
     activeIndex: number;
     setActiveIndex: Dispatch<SetStateAction<number>>;
     resetIndex: () => void;
     onKeyDown: (e: KeyboardEvent_2) => void;
 };
+export { useKeyboardNav as useKeyNavigation }
+export { useKeyboardNav }
 
-export declare interface UseKeyboardNavOptions {
+declare interface UseKeyboardNavOptions {
     itemCount: number;
     onSelect: (index: number) => void;
     onClose: () => void;
     isOpen: boolean;
     loop?: boolean;
 }
+export { UseKeyboardNavOptions as UseKeyNavigationOptions }
+export { UseKeyboardNavOptions }
 
-export declare function useTheme(): MineralTheme;
+declare function useTheme(): ThemeContextValue;
+export { useTheme as useMTheme }
+export { useTheme }
+
+export declare function validateCardNumber(value: string): ValidationResult;
 
 export declare function validateEmail(value: string): ValidationResult;
 
@@ -642,6 +2077,8 @@ export declare function validatePESEL(value: string): ValidationResult;
 
 export declare function validatePhone(value: string, countryCode?: string): ValidationResult;
 
+export declare function validatePostCode(value: string, countryCode?: string): ValidationResult;
+
 export declare function validateRange(min?: number, max?: number): ValidatorFn;
 
 export declare function validateREGON(value: string): ValidationResult;