@consta/uikit 5.20.0 → 5.20.2

package/__internal__/src/components/ContextMenu/types.d.ts

@@ -0,0 +1,193 @@
+import { IconComponent } from '@consta/icons/Icon';
+import { ListPropForm } from '../ListCanary';
+import { ComponentSize } from '../../hooks/useComponentSize';
+import { Animate } from '../../mixs/MixPopoverAnimate';
+import { AsAttributes, AsTags } from '../../utils/types/AsTags';
+import { ClickOutsideHandler } from '../../hooks/useClickOutside/useClickOutside';
+import { PropsWithAsAttributes } from '../../utils/types/PropsWithAsAttributes';
+import { PropsWithHTMLAttributes, PropsWithHTMLAttributesAndRef } from '../../utils/types/PropsWithHTMLAttributes';
+import { Direction, PopoverPropOffset, Position } from '../Popover/Popover';
+export declare const contextMenuSizes: readonly ["m", "xs", "s", "l"];
+export type ContextMenuPropSize = typeof contextMenuSizes[number];
+export declare const contextMenuDefaultSize: ContextMenuPropSize;
+export declare const contextMenuStatus: readonly ["alert", "success", "warning"];
+export type ContextMenuStatus = typeof contextMenuStatus[number];
+export declare const contextMenuDefaultStatus: ContextMenuStatus;
+export declare const contextMenuForm: readonly ["default", "brick", "round"];
+export type ContextMenuForm = ListPropForm;
+export declare const defaultContextMenuForm: "default";
+export declare const contextMenuPropSubMenuDirections: readonly ["rightStartUp", "rightStartDown", "leftStartUp", "leftStartDown"];
+export type ContextMenuPropSubMenuDirection = typeof contextMenuPropSubMenuDirections[number];
+export declare const contextMenuPropDefaultSubMenuDirection: ContextMenuPropSubMenuDirection;
+export type ContextMenuPropOnItemClick<ITEM> = (item: ITEM, params: {
+    e: React.MouseEvent;
+}) => void;
+export type ContextMenuGroupDefault = {
+    label?: string;
+    id: number;
+};
+export type ContextMenuItemDefault = {
+    label: string | number;
+    key?: string | number;
+    rightSide?: React.ReactNode;
+    rightIcon?: IconComponent;
+    leftSide?: React.ReactNode;
+    leftIcon?: IconComponent;
+    subMenu?: ContextMenuItemDefault[];
+    status?: ContextMenuStatus;
+    disabled?: boolean;
+    groupId?: number;
+    onClick?: React.MouseEventHandler;
+    as?: AsTags;
+    attributes?: AsAttributes;
+};
+export type ContextMenuPropSortGroup = (a: string | number, b: string | number) => number;
+export type ContextMenuPropGetItemLabel<ITEM> = (item: ITEM) => string | number;
+export type ContextMenuPropGetItemRightSide<ITEM> = (item: ITEM) => React.ReactNode | undefined;
+export type ContextMenuPropGetItemLeftSide<ITEM> = (item: ITEM) => React.ReactNode | undefined;
+export type ContextMenuPropGetItemSubMenu<ITEM> = (item: ITEM) => ITEM[] | undefined;
+export type ContextMenuPropGetItemStatus<ITEM> = (item: ITEM) => ContextMenuStatus | undefined;
+export type ContextMenuPropGetItemKey<ITEM> = (item: ITEM) => string | number | undefined;
+export type ContextMenuPropGetItemOnClick<ITEM> = (item: ITEM) => React.MouseEventHandler | undefined;
+export type ContextMenuPropGetItemDisabled<ITEM> = (item: ITEM) => boolean | undefined;
+export type ContextMenuPropGetItemAs<ITEM> = (item: ITEM) => AsTags | undefined;
+export type ContextMenuPropGetItemAttributes<ITEM> = (item: ITEM) => AsAttributes | undefined;
+export type ContextMenuPropGetItemGroupId<ITEM> = (item: ITEM) => number | undefined;
+export type ContextMenuPropGetItemRightIcon<ITEM> = (item: ITEM) => IconComponent | undefined;
+export type ContextMenuPropGetItemLeftIcon<ITEM> = (item: ITEM) => IconComponent | undefined;
+export type ContextMenuPropGetGroupLabel<GROUP> = (group: GROUP) => string | undefined;
+export type ContextMenuPropGetGroupId<GROUP> = (group: GROUP) => number;
+type PositioningProps = {
+    anchorRef: React.RefObject<HTMLElement>;
+    position?: never;
+} | {
+    anchorRef?: never;
+    position: Position;
+};
+export type MappersItem<ITEM> = {
+    getItemLabel?: ContextMenuPropGetItemLabel<ITEM>;
+    getItemRightSide?: ContextMenuPropGetItemRightSide<ITEM>;
+    getItemLeftSide?: ContextMenuPropGetItemLeftSide<ITEM>;
+    getItemSubMenu?: ContextMenuPropGetItemSubMenu<ITEM>;
+    getItemStatus?: ContextMenuPropGetItemStatus<ITEM>;
+    getItemDisabled?: ContextMenuPropGetItemDisabled<ITEM>;
+    getItemKey?: ContextMenuPropGetItemKey<ITEM>;
+    getItemOnClick?: ContextMenuPropGetItemOnClick<ITEM>;
+    getItemAs?: ContextMenuPropGetItemAs<ITEM>;
+    getItemAttributes?: ContextMenuPropGetItemAttributes<ITEM>;
+    getItemGroupId?: ContextMenuPropGetItemGroupId<ITEM>;
+    getItemLeftIcon?: ContextMenuPropGetItemLeftIcon<ITEM>;
+    getItemRightIcon?: ContextMenuPropGetItemRightIcon<ITEM>;
+};
+export type MappersGroup<GROUP> = {
+    getGroupLabel?: ContextMenuPropGetGroupLabel<GROUP>;
+    getGroupId?: ContextMenuPropGetGroupId<GROUP>;
+};
+export type Level<ITEM> = {
+    items: ITEM[];
+    activeItem?: string;
+    direction?: Direction;
+    possibleDirections?: readonly Direction[];
+    offset?: PopoverPropOffset;
+    parent?: ITEM;
+    anchorRef?: React.RefObject<HTMLElement>;
+    position?: Position;
+};
+export type AddLevel<ITEM> = (params: {
+    level: number;
+    items: ITEM[];
+    parent?: ITEM;
+    anchorRef?: React.RefObject<HTMLElement>;
+    position?: Position;
+    activeItem: string;
+}) => void;
+export type ContextMenuProps<ITEM = ContextMenuItemDefault, GROUP = ContextMenuGroupDefault> = PropsWithHTMLAttributesAndRef<{
+    items: ITEM[];
+    size?: ContextMenuPropSize;
+    direction?: Direction;
+    offset?: PopoverPropOffset;
+    groups?: GROUP[];
+    sortGroup?: ContextMenuPropSortGroup;
+    onItemClick?: ContextMenuPropOnItemClick<ITEM>;
+    possibleDirections?: readonly Direction[];
+    subMenuDirection?: ContextMenuPropSubMenuDirection;
+    spareDirection?: Direction;
+    onSetDirection?: (direction: Direction) => void;
+    onClickOutside?: ClickOutsideHandler;
+    isOpen?: boolean;
+    form?: ContextMenuForm;
+    isMobile?: boolean;
+    onEsc?: React.KeyboardEventHandler;
+} & MappersItem<ITEM> & MappersGroup<GROUP> & PositioningProps, HTMLDivElement> & (GROUP extends {
+    id: ContextMenuGroupDefault['id'] | unknown;
+} ? {} : {
+    getGroupId: ContextMenuPropGetGroupId<GROUP>;
+}) & (ITEM extends {
+    label: ContextMenuItemDefault['label'];
+} ? {} : {
+    getItemLabel: ContextMenuPropGetItemLabel<ITEM>;
+});
+export type ContextMenuLevelsProps<ITEM = ContextMenuItemDefault, GROUP = ContextMenuGroupDefault> = ContextMenuProps<ITEM, GROUP> & {
+    setComponentSize: React.Dispatch<React.SetStateAction<ComponentSize>>;
+    disableAnimationBack: () => void;
+    enableAnimationBack: () => void;
+};
+export type ContextMenuLevelsComponent = <ITEM = ContextMenuItemDefault, GROUP = ContextMenuGroupDefault>(props: ContextMenuLevelsProps<ITEM, GROUP>) => React.ReactElement | null;
+export type ContextMenuComponent = <ITEM = ContextMenuItemDefault, GROUP = ContextMenuGroupDefault>(props: ContextMenuProps<ITEM, GROUP>) => React.ReactElement | null;
+export type ContextMenuLevelProps<ITEM = ContextMenuItemDefault, GROUP = ContextMenuGroupDefault> = Omit<ContextMenuProps<ITEM, GROUP>, 'subMenuDirection' | 'onClickOutside' | 'setComponentSize' | 'animationBack' | 'disableAnimationBack' | 'enableAnimationBack' | keyof MappersItem<ITEM> | keyof MappersGroup<GROUP>> & {
+    parent?: ITEM;
+    activeLevelDepth: number;
+    levelDepth: number;
+    addLevel: AddLevel<ITEM>;
+    deleteLevel: (level: number) => void;
+    activeItem?: string;
+    onSetDirection?: (direction: Direction) => void;
+    hoveredParenLevel: number;
+    setHoveredParenLevel: (level: number) => void;
+    onEsc?: React.KeyboardEventHandler;
+    animate: Animate;
+} & Required<MappersItem<ITEM>> & Required<MappersGroup<GROUP>>;
+export type ContextMenuLevelComponent = <ITEM, GROUP>(props: ContextMenuLevelProps<ITEM, GROUP>, ref: React.Ref<HTMLElement>) => React.ReactElement | null;
+export type ContextMenuItemProps<AS extends AsTags = 'div'> = PropsWithAsAttributes<Omit<ContextMenuItemDefault, 'onClick' | 'attributes' | 'key'> & {
+    size?: ContextMenuPropSize;
+    active: boolean;
+    withSubMenu: boolean;
+}, AS> & React.RefAttributes<HTMLDivElement>;
+export type ContextMenuItemComponent = <AS extends AsTags = 'div'>(props: ContextMenuItemProps<AS>, ref: React.Ref<HTMLElement>) => React.ReactElement | null;
+export type GetLevelsParams<ITEM> = {
+    levels: Level<ITEM>[];
+    items: ITEM[];
+    getItemSubMenu: ContextMenuPropGetItemSubMenu<ITEM>;
+    getItemKey: ContextMenuPropGetItemKey<ITEM>;
+};
+export type ContextMenuWrapperProps = PropsWithHTMLAttributes<{
+    children: React.ReactNode;
+    isOpen?: boolean;
+    isMobile?: boolean;
+    form?: ContextMenuForm;
+    onClickOutside?: ClickOutsideHandler;
+    spareDirection?: Direction;
+    possibleDirections?: readonly Direction[];
+    size?: ContextMenuPropSize;
+    direction?: Direction;
+    offset?: PopoverPropOffset;
+    anchorRef?: React.RefObject<HTMLElement>;
+    position?: Position;
+    onSetDirection?: (direction: Direction) => void;
+    className?: string;
+    animationBack?: boolean;
+}, HTMLDivElement>;
+export type ContextMenuLevelWrapperProps = PropsWithHTMLAttributesAndRef<{
+    children: React.ReactNode;
+    isMobile?: boolean;
+    onClickOutside?: ClickOutsideHandler;
+    spareDirection?: Direction;
+    possibleDirections?: readonly Direction[];
+    size?: ContextMenuPropSize;
+    direction?: Direction;
+    offset?: PopoverPropOffset;
+    anchorRef?: React.RefObject<HTMLElement>;
+    position?: Position;
+    onSetDirection?: (direction: Direction) => void;
+}, HTMLDivElement>;
+export {};

package/__internal__/src/components/ContextMenu/useMenuNavigation.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { ContextMenuItemDefault, ContextMenuPropGetItemSubMenu } from './types';
+type UseMenuNavigationProps<ITEM = ContextMenuItemDefault> = {
+    items: ITEM[];
+    deleteLevel: () => void;
+    getItemSubMenu: ContextMenuPropGetItemSubMenu<ITEM>;
+    active: boolean;
+    addLevel: (item: ITEM) => void;
+    onEsc?: React.KeyboardEventHandler;
+    level?: number;
+    isMobile?: boolean;
+};
+export declare const useMenuNavigation: (props: UseMenuNavigationProps) => {
+    refs: React.RefObject<HTMLDivElement>[];
+    activeIndex: number;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number>>;
+    setDirection: React.Dispatch<React.SetStateAction<"downCenter" | "upCenter" | "downRight" | "downLeft" | "upRight" | "upLeft" | "leftUp" | "leftCenter" | "leftDown" | "rightUp" | "rightCenter" | "rightDown" | "downStartLeft" | "upStartLeft" | "downStartRight" | "upStartRight" | "leftStartUp" | "leftStartDown" | "rightStartUp" | "rightStartDown" | undefined>>;
+    parentRef: React.RefObject<HTMLDivElement>;
+    containerRef: React.RefObject<HTMLDivElement>;
+};
+export {};

package/__internal__/src/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,5 @@
+import { DatePickerComponent } from './types';
+export declare const COMPONENT_NAME: "DatePicker";
+export declare const DatePicker: DatePickerComponent;
+export * from './helpers';
+export * from './types';

package/__internal__/src/components/DatePicker/DatePickerAdditionalControls/DatePickerAdditionalControls.d.ts

@@ -0,0 +1,12 @@
+import './DatePickerAdditionalControls.css';
+import React from 'react';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { DatePickerAdditionalControlRenderProp, DatePickerPropDateTimeView, DatePickerPropType } from '../types';
+type Props = PropsWithHTMLAttributes<{
+    renderAdditionalControls?: DatePickerAdditionalControlRenderProp;
+    currentVisibleDate?: Date;
+    type: DatePickerPropType;
+    view: DatePickerPropDateTimeView;
+}, HTMLDivElement>;
+export declare const DatePickerAdditionalControls: React.FC<Props>;
+export {};

package/__internal__/src/components/DatePicker/DatePickerDropdown/DatePickerDropdown.d.ts

@@ -0,0 +1,34 @@
+import './DatePickerDropdown.css';
+import React from 'react';
+import { DateTimePropOnChange, DateTimePropType } from '../../DateTime';
+import { DateTimePropDisableDates } from '../../DateTime/helpers/types';
+import { DateRange } from '../../../utils/types/Date';
+import { PropsWithHTMLAttributesAndRef } from '../../../utils/types/PropsWithHTMLAttributes';
+import { DatePickerAdditionalControlRenderProp, DatePickerPropDateTimeView, DatePickerPropDropdownForm } from '../types';
+export type DatePickerDropdownPropOnChange = DateTimePropOnChange;
+export type DatePickerDropdownProps = PropsWithHTMLAttributesAndRef<{
+    anchorRef: React.RefObject<HTMLElement>;
+    currentVisibleDate?: Date;
+    type: DateTimePropType;
+    value?: Date | DateRange;
+    onChange?: DatePickerDropdownPropOnChange;
+    minDate?: Date;
+    maxDate?: Date;
+    events?: Date[];
+    view: DatePickerPropDateTimeView;
+    locale?: Locale;
+    children?: never;
+    form?: DatePickerPropDropdownForm;
+    isOpen?: boolean;
+    onChangeCurrentVisibleDate?: (date: Date) => void;
+    zIndex?: number;
+    renderAdditionalControls?: DatePickerAdditionalControlRenderProp;
+    multiplicitySeconds?: number;
+    multiplicityMinutes?: number;
+    multiplicityHours?: number;
+    timeFor?: 'start' | 'end';
+    disableDates?: DateTimePropDisableDates;
+}, HTMLDivElement>;
+type DatePickerDropdownComponent = (props: DatePickerDropdownProps) => React.ReactElement | null;
+export declare const DatePickerDropdown: DatePickerDropdownComponent;
+export {};

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDate/DatePickerFieldTypeDate.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+export declare const DatePickerFieldTypeDate: React.ForwardRefExoticComponent<{
+    className?: string;
+    value?: Date | null;
+    onChange?: (value: Date | null, props: {
+        e: Event;
+    }) => void;
+    onError?: import("..").DatePickerPropOnError;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    size?: import("../../TextField").TextFieldPropSize;
+    view?: import("../../TextField").TextFieldPropView;
+    form?: import("../../TextField").TextFieldPropForm;
+    status?: import("../../TextField").TextFieldPropStatus;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    autoFocus?: boolean;
+    placeholder?: string;
+    leftSide?: string | import("@consta/icons/Icon").IconComponent;
+    rightSide?: string | import("@consta/icons/Icon").IconComponent;
+    readOnly?: boolean;
+    required?: boolean;
+    tabIndex?: number;
+    inputRef?: React.Ref<HTMLTextAreaElement | HTMLInputElement>;
+    ariaLabel?: string;
+    iconSize?: import("@consta/icons/Icon").IconPropSize;
+    children?: never;
+    format?: string;
+    separator?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    focused?: boolean;
+    label?: string;
+    labelIcon?: import("@consta/icons/Icon").IconComponent;
+    caption?: string;
+    labelPosition?: "top" | "left";
+    withClearButton?: boolean;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "css" | "className" | "id" | "placeholder" | "tabIndex" | "children" | "onFocus" | "onBlur" | "onChange" | "onError" | "size" | "view" | "caption" | "form" | "label" | "separator" | "status" | "name" | "autoFocus" | "disabled" | "value" | "readOnly" | "required" | "inputRef" | "focused" | "ariaLabel" | "labelIcon" | "labelPosition" | "leftSide" | "rightSide" | "withClearButton" | "iconSize" | "minDate" | "maxDate" | "format"> & React.RefAttributes<HTMLDivElement>>;

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDate/helpers.d.ts

@@ -0,0 +1,54 @@
+import { IconComponent, IconPropSize } from '@consta/icons/Icon';
+import { TextFieldPropForm, TextFieldPropSize, TextFieldPropStatus, TextFieldPropView } from '../../TextField';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { DatePickerPropOnError } from '../types';
+type DatePickerFieldTypeDatePropOnChange = (value: Date | null, props: {
+    e: Event;
+}) => void;
+export type DatePickerFieldTypeDateProps = PropsWithHTMLAttributes<{
+    className?: string;
+    value?: Date | null;
+    onChange?: DatePickerFieldTypeDatePropOnChange;
+    onError?: DatePickerPropOnError;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    size?: TextFieldPropSize;
+    view?: TextFieldPropView;
+    form?: TextFieldPropForm;
+    status?: TextFieldPropStatus;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    autoFocus?: boolean;
+    placeholder?: string;
+    leftSide?: string | IconComponent;
+    rightSide?: string | IconComponent;
+    readOnly?: boolean;
+    required?: boolean;
+    tabIndex?: number;
+    inputRef?: React.Ref<HTMLTextAreaElement | HTMLInputElement>;
+    ariaLabel?: string;
+    iconSize?: IconPropSize;
+    children?: never;
+    format?: string;
+    separator?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    focused?: boolean;
+    label?: string;
+    labelIcon?: IconComponent;
+    caption?: string;
+    labelPosition?: 'top' | 'left';
+    withClearButton?: boolean;
+}, HTMLDivElement>;
+type UsePickerProps = {
+    value?: Date | null;
+    onChange?: DatePickerFieldTypeDatePropOnChange;
+    onError?: DatePickerPropOnError;
+    format: string;
+    separator: string;
+    minDate: Date;
+    maxDate: Date;
+};
+export declare const usePicker: (props: UsePickerProps) => readonly [import("react").MutableRefObject<HTMLInputElement | null>, import("react").MouseEventHandler<HTMLButtonElement>];
+export {};

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateRange/DatePickerFieldTypeDateRange.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+export declare const DatePickerFieldTypeDateRange: React.ForwardRefExoticComponent<Omit<import("../DatePickerFieldTypeDate/helpers").DatePickerFieldTypeDateProps, "id" | "placeholder" | "onFocus" | "onBlur" | "onChange" | "name" | "value" | "inputRef" | "leftSide" | "rightSide"> & {
+    onChange?: (value: import("../../../utils/types/Date").DateRange | null, props: {
+        e: Event;
+    }) => void;
+    value?: import("../../../utils/types/Date").DateRange | null;
+    startFieldInputRef?: React.Ref<HTMLInputElement>;
+    endFieldInputRef?: React.Ref<HTMLInputElement>;
+    startFieldLeftSide?: string | import("@consta/icons/Icon").IconComponent;
+    startFieldRightSide?: string | import("@consta/icons/Icon").IconComponent;
+    endFieldLeftSide?: string | import("@consta/icons/Icon").IconComponent;
+    endFieldRightSide?: string | import("@consta/icons/Icon").IconComponent;
+    startFieldRef?: React.Ref<HTMLDivElement>;
+    endFieldRef?: React.Ref<HTMLDivElement>;
+    startFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    startFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    endFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    startFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    startFocused?: boolean;
+    endFocused?: boolean;
+    id?: string;
+    onChangeCurrentVisibleDate?: (date: Date) => void;
+    currentVisibleDate?: Date;
+    startFieldName?: string;
+    endFieldName?: string;
+    startFieldPlaceholder?: string;
+    endFieldPlaceholder?: string;
+} & React.RefAttributes<HTMLDivElement>>;

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateRange/helpers.d.ts

@@ -0,0 +1,35 @@
+import { IconComponent } from '@consta/icons/Icon';
+import React from 'react';
+import { DateRange } from '../../../utils/types/Date';
+import { DatePickerFieldTypeDateProps } from '../DatePickerFieldTypeDate/helpers';
+type DatePickerFieldTypeDateRangePropOnChange = (value: DateRange | null, props: {
+    e: Event;
+}) => void;
+export type DatePickerFieldTypeDateRangeProps = Omit<DatePickerFieldTypeDateProps, 'onChange' | 'value' | 'inputRef' | 'leftSide' | 'rightSide' | 'id' | 'onFocus' | 'onBlur' | 'name' | 'placeholder'> & {
+    onChange?: DatePickerFieldTypeDateRangePropOnChange;
+    value?: DateRange | null;
+    startFieldInputRef?: React.Ref<HTMLInputElement>;
+    endFieldInputRef?: React.Ref<HTMLInputElement>;
+    startFieldLeftSide?: string | IconComponent;
+    startFieldRightSide?: string | IconComponent;
+    endFieldLeftSide?: string | IconComponent;
+    endFieldRightSide?: string | IconComponent;
+    startFieldRef?: React.Ref<HTMLDivElement>;
+    endFieldRef?: React.Ref<HTMLDivElement>;
+    startFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    startFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    endFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    startFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    startFocused?: boolean;
+    endFocused?: boolean;
+    id?: string;
+    onChangeCurrentVisibleDate?: (date: Date) => void;
+    currentVisibleDate?: Date;
+    startFieldName?: string;
+    endFieldName?: string;
+    startFieldPlaceholder?: string;
+    endFieldPlaceholder?: string;
+};
+export {};

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateTime/DatePickerFieldTypeDateTime.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+export declare const DatePickerFieldTypeDateTime: React.ForwardRefExoticComponent<{
+    className?: string;
+    value?: Date | null;
+    onChange?: (value: Date | null, props: {
+        e: Event;
+    }) => void;
+    onError?: import("..").DatePickerPropOnError;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    size?: import("../../TextField").TextFieldPropSize;
+    view?: import("../../TextField").TextFieldPropView;
+    form?: import("../../TextField").TextFieldPropForm;
+    status?: import("../../TextField").TextFieldPropStatus;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    autoFocus?: boolean;
+    placeholder?: string;
+    leftSide?: string | import("@consta/icons/Icon").IconComponent;
+    rightSide?: string | import("@consta/icons/Icon").IconComponent;
+    readOnly?: boolean;
+    required?: boolean;
+    tabIndex?: number;
+    inputRef?: React.Ref<HTMLTextAreaElement | HTMLInputElement>;
+    ariaLabel?: string;
+    iconSize?: import("@consta/icons/Icon").IconPropSize;
+    children?: never;
+    format?: string;
+    separator?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    focused?: boolean;
+    multiplicitySeconds?: number;
+    multiplicityMinutes?: number;
+    multiplicityHours?: number;
+    label?: string;
+    labelIcon?: import("@consta/icons/Icon").IconComponent;
+    caption?: string;
+    labelPosition?: "top" | "left";
+    withClearButton?: boolean;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "css" | "className" | "id" | "placeholder" | "tabIndex" | "children" | "onFocus" | "onBlur" | "onChange" | "onError" | "size" | "view" | "caption" | "form" | "label" | "separator" | "status" | "name" | "autoFocus" | "disabled" | "value" | "readOnly" | "required" | "inputRef" | "focused" | "ariaLabel" | "labelIcon" | "labelPosition" | "leftSide" | "rightSide" | "withClearButton" | "iconSize" | "minDate" | "maxDate" | "multiplicitySeconds" | "multiplicityMinutes" | "multiplicityHours" | "format"> & React.RefAttributes<HTMLDivElement>>;

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateTime/helpers.d.ts

@@ -0,0 +1,61 @@
+import { IconComponent, IconPropSize } from '@consta/icons/Icon';
+import React from 'react';
+import { TextFieldPropForm, TextFieldPropSize, TextFieldPropStatus, TextFieldPropView } from '../../TextField/TextField';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { DatePickerPropOnError } from '../types';
+type DatePickerFieldTypeDateTimePropOnChange = (value: Date | null, props: {
+    e: Event;
+}) => void;
+export type DatePickerFieldTypeDateTimeProps = PropsWithHTMLAttributes<{
+    className?: string;
+    value?: Date | null;
+    onChange?: DatePickerFieldTypeDateTimePropOnChange;
+    onError?: DatePickerPropOnError;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    size?: TextFieldPropSize;
+    view?: TextFieldPropView;
+    form?: TextFieldPropForm;
+    status?: TextFieldPropStatus;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    autoFocus?: boolean;
+    placeholder?: string;
+    leftSide?: string | IconComponent;
+    rightSide?: string | IconComponent;
+    readOnly?: boolean;
+    required?: boolean;
+    tabIndex?: number;
+    inputRef?: React.Ref<HTMLTextAreaElement | HTMLInputElement>;
+    ariaLabel?: string;
+    iconSize?: IconPropSize;
+    children?: never;
+    format?: string;
+    separator?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    focused?: boolean;
+    multiplicitySeconds?: number;
+    multiplicityMinutes?: number;
+    multiplicityHours?: number;
+    label?: string;
+    labelIcon?: IconComponent;
+    caption?: string;
+    labelPosition?: 'top' | 'left';
+    withClearButton?: boolean;
+}, HTMLDivElement>;
+type UsePickerProps = {
+    value?: Date | null;
+    onChange?: DatePickerFieldTypeDateTimePropOnChange;
+    onError?: DatePickerPropOnError;
+    format: string;
+    separator: string;
+    minDate: Date;
+    maxDate: Date;
+    multiplicityHours: number | undefined;
+    multiplicitySeconds: number | undefined;
+    multiplicityMinutes: number | undefined;
+};
+export declare const usePicker: (props: UsePickerProps) => readonly [React.MutableRefObject<HTMLInputElement | null>, React.MouseEventHandler<HTMLButtonElement>];
+export {};

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateTimeRange/DatePickerFieldTypeDateTimeRange.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+export declare const DatePickerFieldTypeDateTimeRange: React.ForwardRefExoticComponent<Omit<import("../DatePickerFieldTypeDateTime/helpers").DatePickerFieldTypeDateTimeProps, "id" | "placeholder" | "onFocus" | "onBlur" | "onChange" | "name" | "value" | "inputRef" | "leftSide" | "rightSide"> & {
+    onChange?: (value: import("../../../utils/types/Date").DateRange | null, props: {
+        e: Event;
+    }) => void;
+    value?: import("../../../utils/types/Date").DateRange | null;
+    startFieldInputRef?: React.Ref<HTMLInputElement>;
+    endFieldInputRef?: React.Ref<HTMLInputElement>;
+    startFieldLeftSide?: string | import("@consta/icons/Icon").IconComponent;
+    startFieldRightSide?: string | import("@consta/icons/Icon").IconComponent;
+    endFieldLeftSide?: string | import("@consta/icons/Icon").IconComponent;
+    endFieldRightSide?: string | import("@consta/icons/Icon").IconComponent;
+    startFieldRef?: React.Ref<HTMLDivElement>;
+    endFieldRef?: React.Ref<HTMLDivElement>;
+    startFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    startFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    endFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    startFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    startFocused?: boolean;
+    endFocused?: boolean;
+    id?: string;
+    onChangeCurrentVisibleDate?: (date: Date) => void;
+    currentVisibleDate?: Date;
+    startFieldName?: string;
+    endFieldName?: string;
+    startFieldPlaceholder?: string;
+    endFieldPlaceholder?: string;
+} & React.RefAttributes<HTMLDivElement>>;

package/__internal__/src/components/DatePicker/DatePickerFieldTypeDateTimeRange/helpers.d.ts

@@ -0,0 +1,34 @@
+import { IconComponent } from '@consta/icons/Icon';
+import { DateRange } from '../../../utils/types/Date';
+import { DatePickerFieldTypeDateTimeProps } from '../DatePickerFieldTypeDateTime/helpers';
+type DatePickerFieldTypeDateTimeRangePropOnChange = (value: DateRange | null, props: {
+    e: Event;
+}) => void;
+export type DatePickerFieldTypeDateTimeRangeProps = Omit<DatePickerFieldTypeDateTimeProps, 'onChange' | 'value' | 'inputRef' | 'leftSide' | 'rightSide' | 'id' | 'onFocus' | 'onBlur' | 'name' | 'placeholder'> & {
+    onChange?: DatePickerFieldTypeDateTimeRangePropOnChange;
+    value?: DateRange | null;
+    startFieldInputRef?: React.Ref<HTMLInputElement>;
+    endFieldInputRef?: React.Ref<HTMLInputElement>;
+    startFieldLeftSide?: string | IconComponent;
+    startFieldRightSide?: string | IconComponent;
+    endFieldLeftSide?: string | IconComponent;
+    endFieldRightSide?: string | IconComponent;
+    startFieldRef?: React.Ref<HTMLDivElement>;
+    endFieldRef?: React.Ref<HTMLDivElement>;
+    startFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnFocus?: React.FocusEventHandler<HTMLElement>;
+    startFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    endFieldOnClick?: React.MouseEventHandler<HTMLElement>;
+    startFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    endFieldOnBlur?: React.FocusEventHandler<HTMLElement>;
+    startFocused?: boolean;
+    endFocused?: boolean;
+    id?: string;
+    onChangeCurrentVisibleDate?: (date: Date) => void;
+    currentVisibleDate?: Date;
+    startFieldName?: string;
+    endFieldName?: string;
+    startFieldPlaceholder?: string;
+    endFieldPlaceholder?: string;
+};
+export {};

package/__internal__/src/components/DatePicker/DatePickerFieldTypeMonth/DatePickerFieldTypeMonth.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+export declare const DatePickerFieldTypeMonth: React.ForwardRefExoticComponent<{
+    className?: string;
+    value?: Date | null;
+    onChange?: (value: Date | null, props: {
+        e: Event;
+    }) => void;
+    onError?: import("..").DatePickerPropOnError;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    size?: import("../../TextField").TextFieldPropSize;
+    view?: import("../../TextField").TextFieldPropView;
+    form?: import("../../TextField").TextFieldPropForm;
+    status?: import("../../TextField").TextFieldPropStatus;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    autoFocus?: boolean;
+    placeholder?: string;
+    leftSide?: string | import("@consta/icons/Icon").IconComponent;
+    rightSide?: string | import("@consta/icons/Icon").IconComponent;
+    readOnly?: boolean;
+    required?: boolean;
+    tabIndex?: number;
+    inputRef?: React.Ref<HTMLTextAreaElement | HTMLInputElement>;
+    ariaLabel?: string;
+    iconSize?: import("@consta/icons/Icon").IconPropSize;
+    children?: never;
+    format?: string;
+    separator?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    focused?: boolean;
+    label?: string;
+    labelIcon?: import("@consta/icons/Icon").IconComponent;
+    caption?: string;
+    labelPosition?: "top" | "left";
+    withClearButton?: boolean;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "css" | "className" | "id" | "placeholder" | "tabIndex" | "children" | "onFocus" | "onBlur" | "onChange" | "onError" | "size" | "view" | "caption" | "form" | "label" | "separator" | "status" | "name" | "autoFocus" | "disabled" | "value" | "readOnly" | "required" | "inputRef" | "focused" | "ariaLabel" | "labelIcon" | "labelPosition" | "leftSide" | "rightSide" | "withClearButton" | "iconSize" | "minDate" | "maxDate" | "format"> & React.RefAttributes<HTMLDivElement>>;