@yr3/ui 1.0.24 → 1.1.1

package/dist/index.d.cts

@@ -4,7 +4,6 @@ import * as csstype from 'csstype';
 import * as _yr3_autocomplete_places from '@yr3/autocomplete-places';
 import { Place, Provider } from '@yr3/autocomplete-places';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Dayjs } from 'dayjs';
 
 type IconProps = SVGProps<SVGSVGElement>;
 type PaletteColor = {
@@ -1016,36 +1015,6 @@ type BoxProps = {
 };
 declare const Box: React$1.FC<BoxProps>;
 
-type TextVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'title' | 'subtitle' | 'body1' | 'body2' | 'caption' | 'button' | 'helper' | 'inherit' | 'code';
-type TextWeight = 'light' | 'regular' | 'medium' | 'semibold' | 'bold' | 'black' | 'thin';
-type TextProps = {
-    children?: React$1.ReactNode;
-    variant?: TextVariant;
-    color?: keyof Theme['colors'];
-    weight?: TextWeight;
-    as?: keyof React$1.JSX.IntrinsicElements;
-    gutters?: number[];
-    ui?: UIProps;
-    style?: React$1.CSSProperties;
-    onClick?: () => void;
-};
-declare const Text: React$1.FC<TextProps>;
-
-type ButtonVariant = 'outlined' | 'filled' | 'text';
-type ButtonProps = React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
-    variant?: ButtonVariant;
-    color?: keyof Theme['colors'];
-    animated?: boolean;
-    gradientBorder?: boolean;
-    ui?: UIProps;
-    size?: 'auto' | 'full';
-    icon?: React$1.ReactNode;
-    propsComponent?: {
-        text?: Omit<TextProps, 'children'>;
-    };
-};
-declare const Button: React$1.FC<ButtonProps>;
-
 type BackdropContextType = {
     open: boolean;
     show: (id: string) => void;
@@ -1088,9 +1057,447 @@ declare const baseTokens: {
 declare const bem: (block: string) => (element?: string, modifiers?: Record<string, any>) => string;
 declare const bemMerge: (...args: any[]) => string;
 
+type DTX = Date | string | number;
+type DTXFormat = {
+    locale?: string;
+    days?: string[];
+    options?: Intl.DateTimeFormatOptions;
+};
+declare const date: (value?: DTX, dateFormat?: DTXFormat) => {
+    date: Date;
+    month: number;
+    parts: Intl.DateTimeFormatPart[];
+    getDateSplit: (value: string) => {
+        year: number;
+        month: number;
+    } | null;
+    getMonth: () => number;
+    getMonthFormat: (month: number) => string;
+    getMonthsFormat: () => string[];
+    setMonth: (month: number) => Date;
+    addMonth: (month: number) => Date;
+    subtractMonth: (month: number) => Date;
+    diferenceMonths: (date: Date) => number;
+    isSameMonth: (date2: Date) => boolean;
+    setYear: (year: number) => Date;
+    getUTCYear: () => number;
+    addYears: (year: number) => Date;
+    subtractYears: (year: number) => Date;
+    diferenceYears: (date: Date) => number;
+    isSameYear: (date2: Date) => boolean;
+    setDay: (day: number) => Date;
+    addDays: (days: number) => Date;
+    getDay: () => number;
+    subtractDays: (days: number) => Date;
+    diferenceDays: (date: Date) => number;
+    isSameDay: (date2: Date) => boolean;
+    addHours: (hours: number) => Date;
+    setHours: (hours: number) => Date;
+    getHours: () => number;
+    subtractHours: (hours: number) => Date;
+    diferenceHours: (date: Date) => number;
+    addMinutes: (minutes: number) => Date;
+    setMinutes: (minutes: number) => Date;
+    getMinutes: () => number;
+    subtractMinutes: (minutes: number) => Date;
+    diferenceMinutes: (date: Date) => number;
+    addSeconds: (seconds: number) => Date;
+    setSeconds: (seconds: number) => Date;
+    getSeconds: () => number;
+    subtractSeconds: (seconds: number) => Date;
+    diferenceSeconds: (date: Date) => number;
+    isToday: () => boolean;
+    isAfter: (date: Date) => boolean;
+    isBefore: (date: Date) => boolean;
+    formatLastMonth: () => string;
+    formatPrevMonth: () => string;
+    getDaysInYear: () => number;
+    getDaysInMonth: () => number;
+    getDayOfWeek: () => number;
+    getDayOfYear: () => number;
+    getWeekOfYear: () => number;
+    getStartOfDay: () => Date;
+    getEndOfDay: () => Date;
+    getStartOfMonth: () => Date;
+    getEndOfMonth: () => Date;
+    getStartOfYear: () => Date;
+    getEndOfYear: () => Date;
+    isLeapYear: () => boolean;
+    isWeekend: () => boolean;
+    isTomorrow: () => boolean;
+    formatDateWithLocale: (locale: string, options?: Intl.DateTimeFormatOptions) => string;
+    formatTimeWithLocale: (locale: string, options?: Intl.DateTimeFormatOptions) => string;
+    formatDateTimeWithLocale: (locale: string, options?: Intl.DateTimeFormatOptions) => string;
+    getDayOfWeekWithLocale: (locale: string) => string;
+    getMonthNameWithLocale: (locale: string) => string;
+    getYearWithLocale: (locale: string) => string;
+    getHourWithLocale: (locale: string) => string;
+    getMinuteWithLocale: (locale: string) => string;
+    getSecondWithLocale: (locale: string) => string;
+    getDayOfYearWithLocale: (locale: string) => string;
+    getTimezoneOffset: () => number;
+    convertToTimezone: (timezone: string) => Date;
+    toDate(): Date;
+    Timestamp(): number;
+    ISO: () => string;
+    UNIX(): number;
+    UTC(): Date;
+    UTCHours(): number;
+    UTCMinutes(): number;
+    UTCSeconds(): number;
+    UTCMilliseconds(): number;
+    UTCWeekendDay(): number;
+    UTCDay(): number;
+    UTCMonth(): number;
+    UTCFullYear(): number;
+};
+declare const dtx: (value?: DTX, dateFormat?: DTXFormat) => {
+    date: Date;
+    isToday(): boolean;
+    isAfter(other: DTX): boolean;
+    isBefore(other: DTX): boolean;
+    format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    setDate(month: number, day: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    addDate(days: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    addDays(days: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    setDay(days: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    dayStart: () => number;
+    days: number;
+    getCurrentUTCDay: () => number;
+    CalendarDaysInMonth(year: number, month: number): number;
+    isWeekend: (day: number) => boolean;
+    addMonth(months: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    setMonth(month: number): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    isMonth: (month: number) => boolean;
+    startOfMonth(): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    endOfMonth(): {
+        date: Date;
+        isToday(): boolean;
+        isAfter(other: DTX): boolean;
+        isBefore(other: DTX): boolean;
+        format(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+        setDate(month: number, day: number): /*elided*/ any;
+        addDate(days: number): /*elided*/ any;
+        addDays(days: number): /*elided*/ any;
+        setDay(days: number): /*elided*/ any;
+        dayStart: () => number;
+        days: number;
+        getCurrentUTCDay: () => number;
+        CalendarDaysInMonth(year: number, month: number): number;
+        isWeekend: (day: number) => boolean;
+        addMonth(months: number): /*elided*/ any;
+        setMonth(month: number): /*elided*/ any;
+        isMonth: (month: number) => boolean;
+        startOfMonth(): /*elided*/ any;
+        endOfMonth(): /*elided*/ any;
+        getMonthsLocale(locale?: string): string[];
+        toDate(): Date;
+        toISOString(): string;
+        CalendarYearFormat(year: number, format?: string): string;
+        calendar: (props: any) => {
+            day: any;
+            date: any;
+            iso: any;
+            month: any;
+            key: any;
+            monthName: any;
+            isToday: any;
+            isPast: any;
+            isFuture: any;
+            isCurrentMonth: any;
+            selected: boolean;
+            data: any;
+        };
+    };
+    getMonthsLocale(locale?: string): string[];
+    toDate(): Date;
+    toISOString(): string;
+    CalendarYearFormat(year: number, format?: string): string;
+    calendar: (props: any) => {
+        day: any;
+        date: any;
+        iso: any;
+        month: any;
+        key: any;
+        monthName: any;
+        isToday: any;
+        isPast: any;
+        isFuture: any;
+        isCurrentMonth: any;
+        selected: boolean;
+        data: any;
+    };
+};
+
 type CalendarDayProps = {
     day: number;
-    date: Dayjs;
+    date: any;
     isToday: boolean;
     isPast: boolean;
     isFuture: boolean;
@@ -1102,25 +1509,21 @@ type CalendarComponentProps = {
     calendar: (CalendarDayProps | null)[][];
     month: number;
     monthLabel: string;
-    yearLabel: string;
-    daysContainer: number[];
-    days: number;
+    yearLabel?: string;
+    daysContainer: any[];
+    days?: number;
     weeks: number;
-    isWeekend: boolean;
-    date: Dayjs;
+    isWeekend?: boolean;
+    date?: any;
     selected: CalendarDayProps | null;
-    currentDay: CalendarDayProps;
+    currentDay?: CalendarDayProps;
     props?: any;
 };
-declare function getMonthCalendar(year: number, month: number, startIndex: number, selected: CalendarDayProps, props?: any): CalendarComponentProps;
+declare function getMonthCalendar(dataFormat: DTXFormat, year: number, month: number, startIndex: number, selected: CalendarDayProps, props?: any): any;
 type CalendarMonthProps = {
     year: number;
     value?: string | null;
-    daysFormat?: {
-        month?: string;
-        months?: string[];
-        value?: string;
-    };
+    format?: DTXFormat;
     data: {
         selected: boolean;
         years: number[];
@@ -1130,7 +1533,7 @@ type CalendarMonthProps = {
         }[];
     };
 };
-declare function getMonthCalendarProps({ year, data, value, daysFormat }: CalendarMonthProps): any;
+declare function getMonthCalendarProps({ year, data, value, format }: CalendarMonthProps): any;
 
 declare const rgbToHex: (r: number, g: number, b: number) => string;
 declare const hexToRgb: (hex: string) => {
@@ -1145,9 +1548,6 @@ declare const lighten: (hex: string, amount: number) => string;
 declare const darken: (hex: string, amount: number) => string;
 declare const alpha: (hex: string, opacity: number) => string;
 
-declare function isEmpty(value: unknown): boolean;
-declare function times<T>(n: number, iteratee: (index: number) => T): T[];
-
 declare const cx: (...args: any[]) => string;
 
 type VariantConfig = {
@@ -1170,9 +1570,252 @@ declare const getCountryCodePhone: (phone: string, countries: CountriesDial[]) =
 declare const getNumberPhone: (phone: string, dial: string) => string;
 
 declare function mergeDeep<T>(target: T, source?: Partial<T>): T;
+declare function mergeInitialProps<T>(initial: T, props?: Partial<T>): T;
 
 declare const inputCurrency: (e: React.KeyboardEvent<HTMLInputElement>, value: string, alloweds: string[]) => void;
 
+declare const utils: {
+    isEmpty(value: unknown): boolean;
+    times<T>(n: number, iteratee: (index: number) => T): T[];
+    map<T, K extends keyof T, V extends keyof T>(array: T[], key: K, valueKey: V): Record<string | number | symbol, T[V]>;
+    get<T, K extends keyof T>(obj: T, key: K): T[K];
+    mergeDeep<T>(target: T, source: Partial<T>): T;
+    omit<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+    pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+    flatten<T>(array: T[][]): T[];
+    unique<T>(array: T[]): T[];
+    debounce<T extends (...args: any[]) => void>(func: T, wait: number): T;
+    throttle<T extends (...args: any[]) => void>(func: T, limit: number): T;
+    once<T extends (...args: any[]) => void>(func: T): T;
+    memoize<T extends (...args: any[]) => any>(func: T): T;
+    range(start: number, end: number, step?: number): number[];
+    random(min: number, max: number): number;
+    clamp(value: number, min: number, max: number): number;
+    capitalize(str: string): string;
+    camelCase(str: string): string;
+    kebabCase(str: string): string;
+    snakeCase(str: string): string;
+    upperCase(str: string): string;
+    difference<T>(array1: T[], array2: T[]): T[];
+    intersection<T>(array1: T[], array2: T[]): T[];
+    union<T>(array1: T[], array2: T[]): T[];
+    zip<T, U>(array1: T[], array2: U[]): [T, U][];
+    unzip<T, U>(array: [T, U][]): [T[], U[]];
+    groupBy<T>(array: T[], key: keyof T): Record<string, T[]>;
+    partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
+    countBy<T>(array: T[], key: keyof T): Record<string, number>;
+    chunk<T>(array: T[], size: number): T[][];
+    compact<T>(array: T[]): T[];
+    concat<T>(...arrays: T[][]): T[];
+    differenceBy<T>(array1: T[], array2: T[], iteratee: (item: T) => any): T[];
+    intersectionBy<T>(array1: T[], array2: T[], iteratee: (item: T) => any): T[];
+    unionBy<T>(array1: T[], array2: T[], iteratee: (item: T) => any): T[];
+    uniqBy<T>(array: T[], iteratee: (item: T) => any): T[];
+    zipWith<T, U, V>(array1: T[], array2: U[], iteratee: (item1: T, item2: U) => V): V[];
+    unzipWith<T, U, V>(array: [T, U][], iteratee: (item1: T, item2: U) => V): V[];
+    without<T>(array: T[], ...values: T[]): T[];
+    xor<T>(array1: T[], array2: T[]): T[];
+    zipObject<T>(keys: (string | number | symbol)[], values: T[]): Record<string | number | symbol, T>;
+    zipObjectDeep<T>(keys: (string | number | symbol)[], values: T[]): Record<string | number | symbol, T>;
+    zipWithDeep<T, U, V>(keys: (string | number | symbol)[], values: T[], iteratee: (value: T) => U): Record<string | number | symbol, U>;
+    first<T>(array: T[]): T | undefined;
+    last<T>(array: T[]): T | undefined;
+    nth<T>(array: T[], n: number): T | undefined;
+    keys<T extends object>(obj: T): (keyof T)[];
+    values<T>(obj: T): T[keyof T][];
+    entries<T>(obj: T): [keyof T, T[keyof T]][];
+    fromEntries<T>(entries: [string | number | symbol, T][]): Record<string | number | symbol, T>;
+    invert<T extends Record<string | number | symbol, string | number | symbol>>(obj: T): Record<T[keyof T], keyof T>;
+    mapValues<T extends object, U>(obj: T, iteratee: (value: T[keyof T], key: keyof T) => U): Record<keyof T, U>;
+    mapKeys<T extends object, U extends string | number | symbol>(obj: T, iteratee: (value: T[keyof T], key: keyof T) => U): Record<U, T[keyof T]>;
+    merge<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    defaults<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    defaultsDeep<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    pickBy<T extends object>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+    omitBy<T extends object>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+    pickByDeep<T extends object>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+    omitByDeep<T extends object>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+    isEmptyObject(obj: object): boolean;
+    isEmptyArray(arr: any[]): boolean;
+    isEmptyString(str: string): boolean;
+    isEmptyValue(value: unknown): boolean;
+    startsWith(str: string, prefix: string): boolean;
+    endsWith(str: string, suffix: string): boolean;
+    includes(str: string, search: string): boolean;
+    repeat(str: string, times: number): string;
+    padStart(str: string, targetLength: number, padString?: string): string;
+    padEnd(str: string, targetLength: number, padString?: string): string;
+    trim(str: string): string;
+    trimStart(str: string): string;
+    trimEnd(str: string): string;
+    truncate(str: string, length: number, omission?: string): string;
+    escape(str: string): string;
+    unescape(str: string): string;
+    capitalizeWords(str: string): string;
+    decapitalize(str: string): string;
+    decapitalizeWords(str: string): string;
+    swapCase(str: string): string;
+    clampNumber(num: number, min: number, max: number): number;
+    randomNumber(min: number, max: number): number;
+    round(num: number, precision?: number): number;
+    floor(num: number, precision?: number): number;
+    ceil(num: number, precision?: number): number;
+    toFixed(num: number, precision?: number): string;
+    toExponential(num: number, precision?: number): string;
+    toPrecision(num: number, precision?: number): string;
+    isInteger(num: number): boolean;
+    isFiniteNumber(num: number): boolean;
+    isNaNValue(num: number): boolean;
+    isSafeInteger(num: number): boolean;
+    parseIntValue(str: string, radix?: number): number;
+    parseFloatValue(str: string): number;
+    toNumber(value: any): number;
+    toInteger(value: any): number;
+    toFinite(value: any): number;
+    toSafeInteger(value: any): number;
+    toFiniteNumber(value: any): number;
+    getValue<T, K extends keyof T>(obj: T, key: K): T[K];
+    setValue<T, K extends keyof T>(obj: T, key: K, value: T[K]): void;
+    hasKey<T extends object, K extends keyof T>(obj: T, key: K): boolean;
+    hasValue<T extends object>(obj: T, value: T[keyof T]): boolean;
+    getNestedValue<T, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, key1: K1, key2: K2): T[K1][K2];
+    setNestedValue<T, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, key1: K1, key2: K2, value: T[K1][K2]): void;
+    hasNestedKey<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, key1: K1, key2: K2): boolean;
+    hasNestedValue<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, key1: K1, key2: K2, value: T[K1][K2]): boolean;
+    getDeepValue<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3];
+    setDeepValue<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, key1: K1, key2: K2, key3: K3, value: T[K1][K2][K3]): void;
+    hasDeepKey<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, key1: K1, key2: K2, key3: K3): boolean;
+    hasDeepValue<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, key1: K1, key2: K2, key3: K3, value: T[K1][K2][K3]): boolean;
+    getValueByPath<T>(obj: T, path: string): any;
+    setValueByPath<T>(obj: T, path: string, value: any): void;
+    hasKeyByPath<T>(obj: T, path: string): boolean;
+    hasValueByPath<T>(obj: T, path: string, value: any): boolean;
+    isNumberValue(value: any): boolean;
+    isStringValue(value: any): boolean;
+    isBooleanValue(value: any): boolean;
+    isObjectValue(value: any): boolean;
+    isArrayValue(value: any): boolean;
+    isFunctionValue(value: any): boolean;
+    isNullValue(value: any): boolean;
+    isUndefinedValue(value: any): boolean;
+    isSymbolValue(value: any): boolean;
+    isBigIntValue(value: any): boolean;
+    isEmail(str: string): boolean;
+    isURL(str: string): boolean;
+    isPhoneNumber(str: string): boolean;
+    isPostalCode(str: string): boolean;
+    isCreditCard(str: string): boolean;
+    isISBN(str: string): boolean;
+    isJSON(str: string): boolean;
+    isXML(str: string): boolean;
+    isBase64(str: string): boolean;
+    isHexadecimal(str: string): boolean;
+    isUUID(str: string): boolean;
+    isIPv4(str: string): boolean;
+    isIPv6(str: string): boolean;
+    isMACAddress(str: string): boolean;
+    isSlug(str: string): boolean;
+    isHexColor(str: string): boolean;
+    isRGBColor(str: string): boolean;
+    hexToRGB(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+    } | null;
+    rgbToHex(r: number, g: number, b: number): string;
+    rgbToHSL(r: number, g: number, b: number): {
+        h: number;
+        s: number;
+        l: number;
+    };
+    hslToRGB(h: number, s: number, l: number): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    hexToHSL(hex: string): {
+        h: number;
+        s: number;
+        l: number;
+    } | null;
+    hslToHex(h: number, s: number, l: number): string;
+    lightenColor(hex: string, amount: number): string | null;
+    darkenColor(hex: string, amount: number): string | null;
+    saturateColor(hex: string, amount: number): string | null;
+    desaturateColor(hex: string, amount: number): string | null;
+    rotateHue(hex: string, degrees: number): string | null;
+    invertColor(hex: string): string | null;
+    isLightColor(hex: string): boolean | null;
+    isDarkColor(hex: string): boolean | null;
+    getContrastColor(hex: string): string | null;
+    blendColors(hex1: string, hex2: string, ratio: number): string | null;
+    mixColors(hex1: string, hex2: string): string | null;
+    shadeColor(hex: string, percent: number): string | null;
+    tintColor(hex: string, percent: number): string | null;
+    generateRandomColor(): string;
+    generateRandomHexColor(): string;
+    generateRandomRGBColor(): string;
+    generateRandomHSLColor(): string;
+    generateRandomColorScheme(baseHex: string, schemeType: "complementary" | "analogous" | "triadic" | "tetradic"): string[] | null;
+    generateGradientColors(startHex: string, endHex: string, steps: number): string[] | null;
+    generateRandomGradient(steps: number): string[];
+    generateRandomColorPalette(count: number): string[];
+    generateMonochromaticPalette(baseHex: string, count: number): string[] | null;
+    generateAnalogousPalette(baseHex: string, count: number): string[] | null;
+    generateComplementaryPalette(baseHex: string): string[] | null;
+    generateTriadicPalette(baseHex: string): string[] | null;
+    generateTetradicPalette(baseHex: string): string[] | null;
+    generateRandomPastelColor(): string;
+    generateRandomVibrantColor(): string;
+    generateRandomMutedColor(): string;
+    generateRandomDarkColor(): string;
+    generateRandomLightColor(): string;
+    generateRandomNeutralColor(): string;
+    generateRandomWarmColor(): string;
+    generateRandomCoolColor(): string;
+    generateRandomEarthToneColor(): string;
+    generateRandomMetallicColor(): string;
+    generateRandomNeonColor(): string;
+    generateRandomPastelPalette(count: number): string[];
+    generateRandomVibrantPalette(count: number): string[];
+    generateRandomMutedPalette(count: number): string[];
+    generateRandomDarkPalette(count: number): string[];
+    generateRandomLightPalette(count: number): string[];
+    generateRandomNeutralPalette(count: number): string[];
+    generateRandomWarmPalette(count: number): string[];
+    generateRandomCoolPalette(count: number): string[];
+    generateRandomEarthTonePalette(count: number): string[];
+    generateRandomMetallicPalette(count: number): string[];
+    generateRandomNeonPalette(count: number): string[];
+    pxToRem(px: number, base?: number): string;
+    remToPx(rem: string, base?: number): number;
+    pxToEm(px: number, base?: number): string;
+    emToPx(em: string, base?: number): number;
+    pxToPercent(px: number, total: number): string;
+    percentToPx(percent: string, total: number): number;
+    remToEm(rem: string, base?: number): string;
+    generateUniqueId(length?: number): string;
+    generateUUID(): string;
+    generateShortId(length?: number): string;
+    generateNanoId(length?: number): string;
+    generateRandomString(length?: number): string;
+    generateRandomHexId(length?: number): string;
+    generateRandomNumericId(length?: number): string;
+    generateRandomAlphaId(length?: number): string;
+    generateRandomAlphanumericId(length?: number): string;
+    generateRandomBase64Id(length?: number): string;
+    generateRandomUrlSafeId(length?: number): string;
+    generateRandomSlug(length?: number): string;
+    generateRandomToken(length?: number): string;
+    generateRandomApiKey(length?: number): string;
+    generateRandomSessionId(length?: number): string;
+    generateRandomPassword(length?: number): string;
+    generateRandomUsername(length?: number): string;
+    generateRandomEmail(length?: number): string;
+    generateRandomDomain(length?: number): string;
+};
+
 type NotistackAnchorProps = {
     vertical: 'top' | 'bottom';
     horizontal: 'left' | 'center' | 'right';
@@ -1220,11 +1863,79 @@ declare function useMediaQuery(query: string | ((theme: any) => string)): boolea
 type Breakpoint = keyof typeof breakpoints;
 declare function useBreakpointValue<T>(values: Partial<Record<Breakpoint, T>>): T | undefined;
 
+type FlexProps = {
+    container?: boolean;
+    spacing?: number;
+    children?: React$1.ReactNode;
+    ui?: UIProps;
+    center?: boolean;
+    between?: boolean;
+    variant?: 'row' | 'column' | 'wrap';
+    gap?: number;
+    style?: React$1.CSSProperties;
+    onClick?: () => void;
+    bordered?: boolean;
+};
+declare const Flex: React$1.FC<FlexProps>;
+
+type LoaderProps = {
+    component?: React$1.ReactNode;
+    loading?: boolean;
+    propsComponent?: {
+        loader?: {
+            ui?: UIProps;
+            style?: React$1.CSSProperties;
+        };
+        spinner?: {
+            size?: 'sm' | 'md' | 'lg' | 'xs';
+            color?: keyof Theme['colors'];
+            type: 'default' | 'dots' | 'fancy';
+        };
+        container?: Omit<FlexProps, 'children'>;
+    };
+};
+declare const Loader: React$1.FC<LoaderProps>;
+
+type TextVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'title' | 'subtitle' | 'body1' | 'body2' | 'caption' | 'button' | 'helper' | 'inherit' | 'code';
+type TextWeight = 'light' | 'regular' | 'medium' | 'semibold' | 'bold' | 'black' | 'thin';
+type TextProps = {
+    children?: React$1.ReactNode;
+    variant?: TextVariant;
+    color?: keyof Theme['colors'];
+    weight?: TextWeight;
+    as?: keyof React$1.JSX.IntrinsicElements;
+    gutters?: number[];
+    ui?: UIProps;
+    style?: React$1.CSSProperties;
+    onClick?: () => void;
+};
+declare const Text: React$1.FC<TextProps>;
+
+type ButtonVariant = 'outlined' | 'filled' | 'text';
+type ButtonProps = React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    variant?: ButtonVariant;
+    color?: keyof Theme['colors'];
+    animated?: boolean;
+    gradientBorder?: boolean;
+    ui?: UIProps;
+    size?: 'auto' | 'full';
+    icon?: React$1.ReactNode;
+    propsComponent?: {
+        text?: Omit<TextProps, 'children'>;
+        loader?: LoaderProps;
+    };
+};
+declare const Button: React$1.FC<ButtonProps>;
+
 type CalendarProps = {
     onSelect?: (day: any) => void;
     propsComponent?: {
         displayButtons?: boolean;
         displayCalendar?: boolean;
+        container?: {
+            ui?: UIProps;
+            style?: React$1.CSSProperties;
+        };
         header?: {
             color?: keyof Theme['colors'];
             ui?: UIProps;
@@ -1233,6 +1944,7 @@ type CalendarProps = {
         day?: {
             color?: keyof Theme['colors'];
             bordered?: boolean;
+            selected?: keyof Theme['colors'];
             ui?: UIProps;
             style?: React$1.CSSProperties;
             component?: React$1.ReactNode;
@@ -1246,13 +1958,22 @@ type CalendarProps = {
             disabled?: boolean;
             onClick?: () => void;
             label?: React$1.ReactNode;
+            color?: keyof Theme['colors'];
+            ui?: UIProps;
         };
         buttonBack?: {
             disabled?: boolean;
             onClick?: () => void;
             label?: React$1.ReactNode;
+            color?: keyof Theme['colors'];
+            ui?: UIProps;
         };
     };
+    buttonsComponent?: {
+        buttonNext?: React$1.ReactNode;
+        buttonBack?: React$1.ReactNode;
+    };
+    dataFormat: DTXFormat;
     mapCalendar?: any;
     onMonthChange?: (month: number) => void;
 };
@@ -1383,9 +2104,10 @@ declare const Label: React$1.FC<LabelProps>;
 type InputProps = Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange'> & {
     label?: string;
     value?: string;
-    pattern?: 'text' | 'email' | 'phone' | 'number' | 'password' | 'search' | 'date' | 'currency';
+    model?: React$1.HTMLAttributes<HTMLInputElement>['inputMode'] | 'currency' | 'email' | 'phone' | 'number';
     variant?: ControlVariants;
     separatorCurrency?: ',' | '.';
+    separatorDecimal?: ',' | '.';
     color?: keyof Theme['colors'];
     onChange?: (e: React$1.ChangeEvent<HTMLInputElement>, value: string) => void;
     error?: string | null;
@@ -1401,9 +2123,10 @@ type InputProps = Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange'
 declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange"> & {
     label?: string;
     value?: string;
-    pattern?: "text" | "email" | "phone" | "number" | "password" | "search" | "date" | "currency";
+    model?: React$1.HTMLAttributes<HTMLInputElement>["inputMode"] | "currency" | "email" | "phone" | "number";
     variant?: ControlVariants;
     separatorCurrency?: "," | ".";
+    separatorDecimal?: "," | ".";
     color?: keyof Theme["colors"];
     onChange?: (e: React$1.ChangeEvent<HTMLInputElement>, value: string) => void;
     error?: string | null;
@@ -1431,11 +2154,7 @@ type MonthSelectorProps = {
             months: number[];
         }[];
     };
-    daysFormat?: {
-        months?: string[];
-        value?: string;
-        month?: string;
-    };
+    format?: DTXFormat;
     onNext?: (value: string) => void;
     onLast?: (value: string) => void;
     onChange: (value: string) => void;
@@ -1478,21 +2197,6 @@ type FadeProps = {
 };
 declare const Fade: React$1.FC<FadeProps>;
 
-type FlexProps = {
-    container?: boolean;
-    spacing?: number;
-    children?: React$1.ReactNode;
-    ui?: UIProps;
-    center?: boolean;
-    between?: boolean;
-    variant?: 'row' | 'column' | 'wrap';
-    gap?: number;
-    style?: React$1.CSSProperties;
-    onClick?: () => void;
-    bordered?: boolean;
-};
-declare const Flex: React$1.FC<FlexProps>;
-
 type GridProps = {
     container?: boolean;
     spacing?: number;
@@ -1599,24 +2303,6 @@ type InputAreaProps = {
 };
 declare const InputArea: React$1.FC<InputAreaProps>;
 
-type LoaderProps = {
-    component?: React$1.ReactNode;
-    loading?: boolean;
-    propsComponent?: {
-        loader?: {
-            ui?: UIProps;
-            style?: React$1.CSSProperties;
-        };
-        spinner?: {
-            size?: 'sm' | 'md' | 'lg';
-            color?: keyof Theme['colors'];
-            type: 'default' | 'dots' | 'fancy';
-        };
-        container?: Omit<FlexProps, 'children'>;
-    };
-};
-declare const Loader: React$1.FC<LoaderProps>;
-
 type ModalContainerProps = {
     children?: React$1.ReactNode;
     size?: 'sm' | 'md' | 'lg';
@@ -1908,4 +2594,4 @@ declare const breakUp: (bp: number) => string;
 declare const breakDown: (bp: number) => string;
 declare function useBreakpoint(queryInput: QueryInput): boolean;
 
-export { Avatar, type AvatarProps, Backdrop, BackdropContext, type BackdropContextType, BackdropProvider, Box, type BoxProps, Button, type ButtonProps, type ButtonVariant, Calendar, type CalendarComponentProps, type CalendarDayProps, type CalendarMonthProps, type CalendarProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Collapse, type CollapseProps, Container, type ContainerProps, Control, ControlContext, type ControlProps, type ControlVariants, type CountriesDial, Divider, type DividerProps, Drawer, type DrawerProps, Fade, type FadeProps, Flex, type FlexProps, Grid, type GridProps, Group, type GroupProps, type GroupsType, type GroupsVariant, IconCalendar, IconClose, IconDown, IconLeft, IconSearch, Image, ImageDropzone, type ImageDropzoneProps, type ImageProps, Input, InputArea, type InputAreaProps, type InputAreaVariant, type InputProps, Label, type LabelProps, Loader, type LoaderProps, Modal, ModalContainer, type ModalContainerProps, type ModalProps, MonthSelector, type MonthSelectorProps, Notistack, type NotistackAnchorProps, NotistackContext, type NotistackContextType, type NotistackProps, NotistackProvider, type Option, Pending, type PendingProps, Phone, type PhoneInputProps, Picker, type PickerChangeEvent, type PickerProps, type PlaceData, PlacesAutocomplete, type PropsPlaces, Radio, type RadioVariant, Select, type SelectChangeEvent, type SelectOptionsProps, type SelectProps, Selector, type SelectorChangeEvent, type SelectorProps, Slide, type SlideContentProps, type SlideProps, type Snack, Switch, type SwitchProps, Text, type TextProps, type TextVariant, type TextWeight, type Theme, ThemeContext, ThemeProvider, type UIProps, adjustColor, alpha, applyTheme, baseTokens, bem, bemMerge, breakDown, breakUp, breakpoints, composeStyles, createPaletteColor, createTheme, createVariants, cx, darken, getContrast, getCountryCodePhone, getDialPhone, getMonthCalendar, getMonthCalendarProps, getNumberPhone, hexToRgb, initTheme, inputCurrency, isEmpty, lighten, mergeDeep, normalizePhone, rgbToHex, text, times, uiStyle, useBackdrop, useBreakpoint, useBreakpointValue, useClickAway, useControl, useMediaQuery, useNotistack, usePlaces, useTheme };
+export { Avatar, type AvatarProps, Backdrop, BackdropContext, type BackdropContextType, BackdropProvider, Box, type BoxProps, Button, type ButtonProps, type ButtonVariant, Calendar, type CalendarComponentProps, type CalendarDayProps, type CalendarMonthProps, type CalendarProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Collapse, type CollapseProps, Container, type ContainerProps, Control, ControlContext, type ControlProps, type ControlVariants, type CountriesDial, Divider, type DividerProps, Drawer, type DrawerProps, Fade, type FadeProps, Flex, type FlexProps, Grid, type GridProps, Group, type GroupProps, type GroupsType, type GroupsVariant, IconCalendar, IconClose, IconDown, IconLeft, IconSearch, Image, ImageDropzone, type ImageDropzoneProps, type ImageProps, Input, InputArea, type InputAreaProps, type InputAreaVariant, type InputProps, Label, type LabelProps, Loader, type LoaderProps, Modal, ModalContainer, type ModalContainerProps, type ModalProps, MonthSelector, type MonthSelectorProps, Notistack, type NotistackAnchorProps, NotistackContext, type NotistackContextType, type NotistackProps, NotistackProvider, type Option, Pending, type PendingProps, Phone, type PhoneInputProps, Picker, type PickerChangeEvent, type PickerProps, type PlaceData, PlacesAutocomplete, type PropsPlaces, Radio, type RadioVariant, Select, type SelectChangeEvent, type SelectOptionsProps, type SelectProps, Selector, type SelectorChangeEvent, type SelectorProps, Slide, type SlideContentProps, type SlideProps, type Snack, Switch, type SwitchProps, Text, type TextProps, type TextVariant, type TextWeight, type Theme, ThemeContext, ThemeProvider, type UIProps, adjustColor, alpha, applyTheme, baseTokens, bem, bemMerge, breakDown, breakUp, breakpoints, composeStyles, createPaletteColor, createTheme, createVariants, cx, darken, date, dtx, getContrast, getCountryCodePhone, getDialPhone, getMonthCalendar, getMonthCalendarProps, getNumberPhone, hexToRgb, initTheme, inputCurrency, lighten, mergeDeep, mergeInitialProps, normalizePhone, rgbToHex, text, uiStyle, useBackdrop, useBreakpoint, useBreakpointValue, useClickAway, useControl, useMediaQuery, useNotistack, usePlaces, useTheme, utils };