@consta/uikit 5.20.0 → 5.20.2

package/__internal__/src/components/SelectComponentsDeprecated/SelectDropdown/SelectDropdown.d.ts

@@ -0,0 +1,38 @@
+import './SelectDropdown.css';
+import React from 'react';
+import { SelectAllItem } from '../../../utils/getGroups';
+import { GetOptionPropsResult, OptionForCreate, OptionProps } from '../../../hooks/useSelect/useSelect';
+import { PropsWithJsxAttributes } from '../../../utils/types/PropsWithJsxAttributes';
+import { PopoverPropOffset } from '../../Popover/Popover';
+import { PropSize, RenderItemProps } from '../types';
+export declare const selectDropdownForm: readonly ["default", "brick", "round"];
+export type SelectDropdownPropForm = typeof selectDropdownForm[number];
+export declare const defaultSelectDropdownPropForm: "default";
+type Props<ITEM, GROUP> = PropsWithJsxAttributes<{
+    size: PropSize;
+    controlRef: React.MutableRefObject<HTMLDivElement | null>;
+    dropdownRef: React.Ref<HTMLDivElement>;
+    getOptionProps(props: OptionProps<ITEM>): GetOptionPropsResult;
+    form: SelectDropdownPropForm;
+    isOpen: boolean;
+    offset?: PopoverPropOffset | 'none';
+    isLoading?: boolean;
+    renderItem: (props: RenderItemProps<ITEM>) => JSX.Element | null;
+    visibleItems: (OptionForCreate | {
+        items: Array<SelectAllItem | ITEM>;
+        key: string | number;
+        group?: GROUP;
+        groupIndex: number;
+        checkedCount?: number;
+        totalCount?: number;
+    })[];
+    getGroupLabel?: (group: GROUP) => string;
+    labelForCreate?: string;
+    labelForNotFound?: string;
+    labelForEmptyItems?: string;
+    notFound?: boolean;
+    hasItems?: boolean;
+}>;
+type SelectDropdown = <ITEM, GROUP>(props: Props<ITEM, GROUP>) => React.ReactElement | null;
+export declare const SelectDropdown: SelectDropdown;
+export {};

package/__internal__/src/components/SelectComponentsDeprecated/SelectGroupLabel/SelectGroupLabel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { PropSize } from '../types';
+type SelectGroupLabelProps = PropsWithHTMLAttributes<{
+    label: string;
+    size: PropSize;
+    indent: 'normal' | 'increased';
+}, HTMLDivElement>;
+export declare const SelectGroupLabel: React.FC<SelectGroupLabelProps>;
+export {};

package/__internal__/src/components/SelectComponentsDeprecated/SelectItem/SelectItem.d.ts

@@ -0,0 +1,17 @@
+import './SelectItem.css';
+import React from 'react';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { CheckboxPropSize } from '../../Checkbox/Checkbox';
+import { PropSize } from '../types';
+export type SelectItemProps = PropsWithHTMLAttributes<{
+    label: string;
+    active: boolean;
+    hovered: boolean;
+    multiple: boolean;
+    size: PropSize;
+    indent: 'normal' | 'increased';
+    disabled: boolean | undefined;
+}, HTMLDivElement>;
+export declare const sizeCheckboxMap: Record<PropSize, CheckboxPropSize>;
+export declare const cnSelectItem: import("@bem-react/classname").ClassNameFormatter;
+export declare const SelectItem: React.FC<SelectItemProps>;

package/__internal__/src/components/SelectComponentsDeprecated/SelectItemAll/SelectSelectAll.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { PropSize } from '../types';
+export type SelectItemAllProps = PropsWithHTMLAttributes<{
+    checked: boolean;
+    intermediate?: boolean;
+    size: PropSize;
+    hovered?: boolean;
+    indent?: 'normal' | 'increased';
+    countItems?: number;
+    total?: number;
+}, HTMLDivElement>;
+export declare const cnSelectItemAll: import("@bem-react/classname").ClassNameFormatter;
+export declare const SelectItemAll: (props: SelectItemAllProps) => JSX.Element;

package/__internal__/src/components/SelectComponentsDeprecated/SelectLoader/SelectLoader.d.ts

@@ -0,0 +1,9 @@
+import './SelectLoader.css';
+import { PropSize } from '../types';
+type Props = {
+    mode?: 'empty' | 'blur';
+    size?: PropSize;
+};
+export declare const cnSelectLoader: import("@bem-react/classname").ClassNameFormatter;
+export declare const SelectLoader: (props: Props) => JSX.Element;
+export {};

package/__internal__/src/components/SelectComponentsDeprecated/SelectValueTag/SelectValueTag.d.ts

@@ -0,0 +1,12 @@
+import './SelectValueTag.css';
+import React from 'react';
+type SelectValueTagProps = {
+    label: string;
+    size: 's' | 'm' | 'l' | 'xs';
+    children?: never;
+    disabled?: boolean;
+    handleRemove?: (e: React.SyntheticEvent) => void;
+};
+export declare const cnSelectValueTag: import("@bem-react/classname").ClassNameFormatter;
+export declare const SelectValueTag: React.FC<SelectValueTagProps>;
+export {};

package/__internal__/src/components/SelectComponentsDeprecated/cnSelect.d.ts

@@ -0,0 +1,3 @@
+import './Select.css';
+export declare const COMPONENT_NAME: "Select";
+export declare const cnSelect: import("@bem-react/classname").ClassNameFormatter;

package/__internal__/src/components/SelectComponentsDeprecated/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultLabelForNotFound = "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E";
+export declare const defaultLabelForCreate = "";
+export declare const defaultLabelForEmptyItems = "\u0421\u043F\u0438\u0441\u043E\u043A \u043F\u0443\u0441\u0442";
+export declare const getInputWidth: (controlInnerRef: React.RefObject<HTMLDivElement>, helperInputFakeElement: React.RefObject<HTMLDivElement>) => number;

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

@@ -0,0 +1,33 @@
+import { RefObject } from 'react';
+export declare const propSize: readonly ["m", "xs", "s", "l"];
+export type PropSize = typeof propSize[number];
+export declare const defaultPropSize: "m";
+export declare const propForm: readonly ["default", "defaultClear", "defaultBrick", "brick", "brickDefault", "brickClear", "brickRound", "round", "roundClear", "roundBrick", "clearRound", "clearDefault", "clearBrick", "clearClear"];
+export type PropForm = typeof propForm[number];
+export declare const defaultPropForm: "default";
+export declare const propView: readonly ["default", "clear"];
+export type PropView = typeof propView[number];
+export declare const defaultPropView: "default";
+export declare const propStatus: readonly ["alert", "warning", "success"];
+export type PropStatus = typeof propStatus[number];
+export type CommonSelectProps<ITEM> = {
+    options: ITEM[];
+    id: string;
+    placeholder?: string;
+    ariaLabel?: string;
+    getOptionLabel(arg: ITEM): string;
+    getOptionKey?(arg: ITEM): string | number;
+    onBlur?: (event?: React.FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (event?: React.FocusEvent<HTMLInputElement>) => void;
+    children?: never;
+    dropdownClassName?: string;
+    dropdownRef?: RefObject<HTMLDivElement>;
+    name?: string;
+};
+export type RenderItemProps<ITEM> = {
+    item: ITEM;
+    active: boolean;
+    hovered: boolean;
+    onClick: (e: React.SyntheticEvent) => void;
+    onMouseEnter: (e: React.SyntheticEvent) => void;
+};

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

@@ -0,0 +1,4 @@
+import '../SelectComponentsDeprecated/Select.css';
+import { SelectComponent } from './helpers';
+export declare const Select: SelectComponent;
+export * from './helpers';

package/__internal__/src/components/SelectDeprecated/helpers.d.ts

@@ -0,0 +1,154 @@
+import { IconComponent, IconPropSize } from '@consta/icons/Icon';
+import React from 'react';
+import { PropsWithHTMLAttributesAndRef } from '../../utils/types/PropsWithHTMLAttributes';
+import { PropForm, PropSize, PropStatus, PropView, RenderItemProps } from '../SelectComponentsDeprecated/types';
+export type DefaultItem = {
+    label: string;
+    id: string | number;
+    groupId?: string | number;
+    disabled?: boolean;
+};
+export type DefaultGroup = {
+    label: string;
+    id: string | number;
+};
+type PropValue<ITEM> = ITEM | null | undefined;
+type RenderValueProps<ITEM> = {
+    item: ITEM;
+};
+export type PropGetItemLabel<ITEM> = (item: ITEM) => string;
+export type PropGetItemKey<ITEM> = (item: ITEM) => string | number;
+export type PropGetItemGroupKey<ITEM> = (item: ITEM) => string | number | undefined;
+export type PropGetItemDisabled<ITEM> = (item: ITEM) => boolean | undefined;
+export type PropGetGroupKey<GROUP> = (group: GROUP) => string | number;
+export type PropGetGroupLabel<GROUP> = (group: GROUP) => string;
+export type PropRenderItem<ITEM> = (props: RenderItemProps<ITEM>) => React.ReactElement | null;
+export type PropRenderValue<ITEM> = (props: RenderValueProps<ITEM>) => React.ReactElement | null;
+export type SelectProps<ITEM = DefaultItem, GROUP = DefaultGroup> = PropsWithHTMLAttributesAndRef<{
+    items: ITEM[];
+    onChange: (props: {
+        value: ITEM | null;
+        e: React.SyntheticEvent;
+    }) => void;
+    disabled?: boolean;
+    form?: PropForm;
+    dropdownForm?: 'default' | 'brick' | 'round';
+    size?: PropSize;
+    view?: PropView;
+    status?: PropStatus;
+    focused?: boolean;
+    multiple?: boolean;
+    placeholder?: string;
+    ariaLabel?: string;
+    dropdownClassName?: string;
+    dropdownRef?: React.RefObject<HTMLDivElement>;
+    required?: boolean;
+    name?: string;
+    isLoading?: boolean;
+    labelForEmptyItems?: string;
+    value?: PropValue<ITEM>;
+    renderItem?: PropRenderItem<ITEM>;
+    renderValue?: PropRenderValue<ITEM>;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    inputRef?: React.RefObject<HTMLInputElement>;
+    groups?: GROUP[];
+    getItemLabel?: PropGetItemLabel<ITEM>;
+    getItemKey?: PropGetItemKey<ITEM>;
+    getItemGroupKey?: PropGetItemGroupKey<ITEM>;
+    getItemDisabled?: PropGetItemDisabled<ITEM>;
+    getGroupLabel?: PropGetGroupLabel<GROUP>;
+    getGroupKey?: PropGetGroupKey<GROUP>;
+    label?: string;
+    labelIcon?: IconComponent;
+    labelPosition?: 'top' | 'left';
+    caption?: string;
+}, HTMLDivElement> & (ITEM extends {
+    label: DefaultItem['label'];
+} ? {} : {
+    getItemLabel: PropGetItemLabel<ITEM>;
+}) & (ITEM extends {
+    id: DefaultItem['id'];
+} ? {} : {
+    getItemKey: PropGetItemKey<ITEM>;
+}) & (GROUP extends {
+    label: DefaultGroup['label'];
+} ? {} : {
+    getGroupLabel: PropGetGroupLabel<GROUP>;
+}) & (GROUP extends {
+    id: DefaultGroup['id'];
+} ? {} : {
+    getGroupKey: PropGetGroupKey<GROUP>;
+});
+export type SelectComponent = <ITEM = DefaultItem, GROUP = DefaultGroup>(props: SelectProps<ITEM, GROUP>) => React.ReactElement | null;
+export declare const defaultGetItemKey: PropGetItemKey<DefaultItem>;
+export declare const defaultGetItemLabel: PropGetItemLabel<DefaultItem>;
+export declare const defaultGetItemGroupKey: PropGetItemGroupKey<DefaultItem>;
+export declare const defaultGetItemDisabled: PropGetItemDisabled<DefaultItem>;
+export declare const defaultGetGroupKey: PropGetGroupKey<DefaultGroup>;
+export declare const defaultGetGroupLabel: PropGetGroupLabel<DefaultGroup>;
+export declare function withDefaultGetters<ITEM, GROUP>(props: SelectProps<ITEM, GROUP>): {
+    items: ITEM[];
+    onChange: (props: {
+        value: ITEM | null;
+        e: React.SyntheticEvent;
+    }) => void;
+    disabled?: boolean;
+    form?: PropForm;
+    dropdownForm?: "default" | "brick" | "round";
+    size?: PropSize;
+    view?: PropView;
+    status?: PropStatus;
+    focused?: boolean;
+    multiple?: boolean;
+    placeholder?: string;
+    ariaLabel?: string;
+    dropdownClassName?: string;
+    dropdownRef?: React.RefObject<HTMLDivElement>;
+    required?: boolean;
+    name?: string;
+    isLoading?: boolean;
+    labelForEmptyItems?: string;
+    value?: PropValue<ITEM>;
+    renderItem?: PropRenderItem<ITEM> | undefined;
+    renderValue?: PropRenderValue<ITEM> | undefined;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    inputRef?: React.RefObject<HTMLInputElement>;
+    groups?: GROUP[] | undefined;
+    getItemLabel?: PropGetItemLabel<ITEM> | undefined;
+    getItemKey?: PropGetItemKey<ITEM> | undefined;
+    getItemGroupKey?: PropGetItemGroupKey<ITEM> | undefined;
+    getItemDisabled?: PropGetItemDisabled<ITEM> | undefined;
+    getGroupLabel?: PropGetGroupLabel<GROUP> | undefined;
+    getGroupKey?: PropGetGroupKey<GROUP> | undefined;
+    label?: string;
+    labelIcon?: IconComponent;
+    labelPosition?: "top" | "left";
+    caption?: string;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "css" | "placeholder" | "onFocus" | "onBlur" | "onChange" | "size" | "view" | "caption" | "form" | "label" | "status" | "name" | "disabled" | "value" | "multiple" | "required" | "inputRef" | "items" | "dropdownForm" | "focused" | "ariaLabel" | "dropdownClassName" | "dropdownRef" | "isLoading" | "labelForEmptyItems" | "renderItem" | "renderValue" | "groups" | "getItemLabel" | "getItemKey" | "getItemGroupKey" | "getItemDisabled" | "getGroupLabel" | "getGroupKey" | "labelIcon" | "labelPosition"> & React.RefAttributes<HTMLDivElement> & (ITEM extends {
+    label: DefaultItem["label"];
+} ? {} : {
+    getItemLabel: PropGetItemLabel<ITEM>;
+}) & (ITEM extends {
+    id: DefaultItem["id"];
+} ? {} : {
+    getItemKey: PropGetItemKey<ITEM>;
+}) & (GROUP extends {
+    label: DefaultGroup["label"];
+} ? {} : {
+    getGroupLabel: PropGetGroupLabel<GROUP>;
+}) & (GROUP extends {
+    id: DefaultGroup["id"];
+} ? {} : {
+    getGroupKey: PropGetGroupKey<GROUP>;
+}) & {
+    getItemLabel: PropGetItemLabel<DefaultItem> | PropGetItemLabel<ITEM>;
+    getItemKey: PropGetItemKey<DefaultItem> | PropGetItemKey<ITEM>;
+    getItemGroupKey: PropGetItemGroupKey<DefaultItem> | PropGetItemGroupKey<ITEM>;
+    getItemDisabled: PropGetItemDisabled<DefaultItem> | PropGetItemDisabled<ITEM>;
+    getGroupLabel: PropGetGroupLabel<DefaultGroup> | PropGetGroupLabel<GROUP>;
+    getGroupKey: PropGetGroupKey<DefaultGroup> | PropGetGroupKey<GROUP>;
+};
+export declare const iconSizeMap: Record<PropSize, IconPropSize>;
+export {};

package/__internal__/src/components/SelectDeprecated/index.d.ts

@@ -0,0 +1 @@
+export * from './SelectDeprecated';

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

@@ -0,0 +1,39 @@
+import './Sidebar.css';
+import React from 'react';
+import { AsTagAttribute } from '../../utils/types/AsTags';
+import { PropsWithHTMLAttributes } from '../../utils/types/PropsWithHTMLAttributes';
+declare const sidebarPropPosition: readonly ["right", "bottom", "left", "top"];
+type SidebarPropPosition = typeof sidebarPropPosition[number];
+export declare const sidebarPropSize: readonly ["s", "m", "l", "full", "1/2", "1/3", "1/4", "2/3", "3/4"];
+export type SidebarPropSize = typeof sidebarPropSize[number];
+type SidebarProps = PropsWithHTMLAttributes<{
+    isOpen?: boolean;
+    onClose?: () => void;
+    onOpen?: () => void;
+    hasOverlay?: boolean;
+    onClickOutside?: (event: MouseEvent) => void;
+    onEsc?: (event: KeyboardEvent) => void;
+    position?: SidebarPropPosition;
+    size?: SidebarPropSize;
+    rootClassName?: string;
+    children?: React.ReactNode;
+    container?: HTMLDivElement | undefined;
+    afterClose?: () => void;
+}, HTMLDivElement>;
+type SidebarContentProps = {
+    className?: string;
+    children: React.ReactNode;
+};
+type SidebarActionsProps = {
+    className?: string;
+    children: React.ReactNode;
+};
+export declare const cnSidebar: import("@bem-react/classname").ClassNameFormatter;
+declare const SidebarContent: React.FC<SidebarContentProps>;
+declare const SidebarActions: React.FC<SidebarActionsProps>;
+interface SidebarComponent extends React.FC<SidebarProps>, AsTagAttribute<'div'> {
+    Content: typeof SidebarContent;
+    Actions: typeof SidebarActions;
+}
+export declare const Sidebar: SidebarComponent;
+export {};

package/__internal__/src/components/Sidebar/index.d.ts

@@ -0,0 +1 @@
+export * from './Sidebar';

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

@@ -0,0 +1,5 @@
+import './Skeleton.css';
+export { SkeletonBrick } from './SkeletonBrick/SkeletonBrick';
+export { SkeletonCircle } from './SkeletonCircle/SkeletonCircle';
+export { SkeletonText } from './SkeletonText/SkeletonText';
+export declare const cnSkeleton: import("@bem-react/classname").ClassNameFormatter;

package/__internal__/src/components/Skeleton/SkeletonBrick/SkeletonBrick.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+type SkeletonBrickProps = PropsWithHTMLAttributes<{
+    width?: CSSProperties['width'];
+    height: CSSProperties['height'];
+}, HTMLDivElement>;
+export declare const SkeletonBrick: ({ className, width, height, style, ...otherProps }: SkeletonBrickProps) => JSX.Element;
+export {};

package/__internal__/src/components/Skeleton/SkeletonCircle/SkeletonCircle.d.ts

@@ -0,0 +1,8 @@
+import './SkeletonCircle.css';
+import { CSSProperties } from 'react';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+type SkeletonCircleProps = PropsWithHTMLAttributes<{
+    size: CSSProperties['width'] & CSSProperties['height'];
+}, HTMLDivElement>;
+export declare const SkeletonCircle: ({ className, size, style, ...otherProps }: SkeletonCircleProps) => JSX.Element;
+export {};

package/__internal__/src/components/Skeleton/SkeletonText/SkeletonText.d.ts

@@ -0,0 +1,13 @@
+import './SkeletonText.css';
+import React from 'react';
+import { TextPropLineHeight, TextPropSize } from '../../Text';
+import { PropsWithHTMLAttributes } from '../../../utils/types/PropsWithHTMLAttributes';
+import { SkeletonBrick } from '../Skeleton';
+type SkeletonTextProps = PropsWithHTMLAttributes<{
+    rows: number;
+    fontSize?: TextPropSize;
+    lineHeight?: TextPropLineHeight;
+}, HTMLDivElement>;
+export declare const getRowWidth: (idx: number, total: number) => React.ComponentProps<typeof SkeletonBrick>["height"];
+export declare const SkeletonText: React.FC<SkeletonTextProps>;
+export {};

package/__internal__/src/components/Skeleton/index.d.ts

@@ -0,0 +1 @@
+export * from './Skeleton';

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

@@ -0,0 +1,4 @@
+import './Slider.css';
+import { SliderComponent } from './helper';
+export declare const COMPONENT_NAME: "Slider";
+export declare const Slider: SliderComponent;

package/__internal__/src/components/Slider/SliderInput/SliderInput.d.ts

@@ -0,0 +1,15 @@
+import './SliderInput.css';
+import React from 'react';
+import { TextFieldProps } from '../../TextField/TextField';
+type Props = Omit<TextFieldProps<'number'>, 'value' | 'onChange' | 'min' | 'max' | 'step'> & {
+    value?: number;
+    step?: number | number[];
+    min?: number;
+    max?: number;
+    onChange?: (props: {
+        e?: React.ChangeEvent | React.MouseEvent | React.KeyboardEvent;
+        value: number;
+    }) => void;
+};
+export declare const SliderInput: (props: Props) => JSX.Element;
+export {};

package/__internal__/src/components/Slider/SliderLine/SliderLine.d.ts

@@ -0,0 +1,3 @@
+import './SliderLine.css';
+import { SliderLineProps } from '../helper';
+export declare const SliderLine: (props: SliderLineProps) => JSX.Element;

package/__internal__/src/components/Slider/SliderPoint/SliderPoint.d.ts

@@ -0,0 +1,3 @@
+import './SliderPoint.css';
+import { SliderPointProps } from '../helper';
+export declare const SliderPoint: (props: SliderPointProps) => JSX.Element;

package/__internal__/src/components/Slider/helper.d.ts

@@ -0,0 +1,93 @@
+import { IconComponent } from '@consta/icons/Icon';
+import React from 'react';
+import { PropsWithHTMLAttributes } from '../../utils/types/PropsWithHTMLAttributes';
+import { Direction } from '../Popover';
+import { ActiveButton } from './useSlider/helper';
+export declare const sliderPropStatus: readonly ["alert", "warning", "success"];
+export type SliderPropStatus = typeof sliderPropStatus[number];
+export declare const sliderPropStatusDefault: "alert";
+export type SliderPropView = 'default' | 'division';
+export declare const sliderPropSize: readonly ["s", "xs", "m", "l"];
+export type SliderPropSize = typeof sliderPropSize[number];
+export declare const sliderPropSizeDefault: SliderPropSize;
+export type SliderValue<RANGE> = RANGE extends true ? [number, number] : number;
+export type SliderPropOnChange<RANGE> = (value: SliderValue<RANGE>, prop: {
+    e?: Event | React.TouchEvent | React.MouseEvent | React.KeyboardEvent | React.ChangeEvent;
+}) => void;
+type SliderPropTooltipFormatter = (value: number | undefined) => string;
+type Side = IconComponent | 'input';
+type Props<RANGE extends boolean = false> = {
+    className?: string;
+    step?: number | number[];
+    view?: SliderPropView;
+    disabled?: boolean;
+    range?: RANGE;
+    withTooltip?: boolean;
+    value: SliderValue<RANGE>;
+    label?: string;
+    labelIcon?: IconComponent;
+    caption?: string;
+    status?: SliderPropStatus;
+    min?: number;
+    size?: SliderPropSize;
+    max?: number;
+    onChange?: SliderPropOnChange<RANGE>;
+    onAfterChange?: SliderPropOnChange<RANGE>;
+    leftSide?: Side;
+    tooltipFormatter?: SliderPropTooltipFormatter;
+    rightSide?: Side;
+    tooltipDirection?: Direction;
+    tooltipPossibleDirections?: Direction[];
+};
+export type Line = {
+    width: number;
+    active: boolean;
+    size?: number[];
+};
+export type SliderLineProps = {
+    view?: SliderPropView;
+    lines: Line[];
+    disabled?: boolean;
+    hovered?: boolean;
+    onHover?: (hovered: boolean) => void;
+};
+export type SliderPointProps = PropsWithHTMLAttributes<{
+    value?: number;
+    disabled?: boolean;
+    focused?: boolean;
+    hovered?: boolean;
+    withTooltip?: boolean;
+    handlePress?: (typeButton: ActiveButton) => void;
+    buttonLabel?: ActiveButton;
+    buttonRef?: React.RefObject<HTMLButtonElement>;
+    popoverPosition?: TrackPosition;
+    tooltipFormatter?: SliderPropTooltipFormatter;
+    onFocus?: (e: React.FocusEvent<HTMLButtonElement> | React.MouseEvent, button: ActiveButton) => void;
+    onKeyPress?: (e: React.KeyboardEvent, typeButton?: ActiveButton) => void;
+    onHover?: (hovered: boolean) => void;
+    position: number;
+    active?: boolean;
+    tooltipZIndex?: number;
+    tooltipDirection?: Direction;
+    tooltipPossibleDirections?: Direction[];
+}, HTMLButtonElement>;
+export type SliderProps<RANGE extends boolean> = PropsWithHTMLAttributes<Props<RANGE>, HTMLDivElement>;
+export type SliderComponent = <RANGE extends boolean = false>(props: SliderProps<RANGE>) => React.ReactElement | null;
+export declare const isRangeParams: (params: Props<boolean>) => params is Props<true>;
+export declare const isNotRangeParams: (params: Props<boolean>) => params is Props<false>;
+export declare const defaultTooltipFormatter: SliderPropTooltipFormatter;
+export type TrackPosition = {
+    x: number;
+    y: number;
+} | null;
+export declare const getValueForInput: (props: SliderProps<boolean>, field: 0 | 1) => number;
+type GetOnChangeForInputReturned = (props: {
+    e?: React.ChangeEvent | React.MouseEvent | React.KeyboardEvent;
+    value: number;
+}) => void;
+export declare const getOnChangeForInput: (props: SliderProps<boolean>, field: 0 | 1) => GetOnChangeForInputReturned;
+export declare const getIcon: (side?: Side) => IconComponent | undefined;
+export declare const getMaxForStartField: (props: SliderProps<boolean>) => number | undefined;
+export declare const getMinForEndField: (props: SliderProps<boolean>) => number | undefined;
+export declare const getValidStep: (min: number, max: number, step?: number | number[]) => number | number[];
+export {};

package/__internal__/src/components/Slider/index.d.ts

@@ -0,0 +1 @@
+export * from './Slider';

package/__internal__/src/components/Slider/useSlider/helper.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { SliderPropOnChange, SliderValue, TrackPosition } from '../helper';
+export type ActiveButton = 0 | 1 | null | undefined;
+export type Stationing = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type UseSliderProps<RANGE extends boolean = false> = {
+    disabled: boolean;
+    range?: RANGE;
+    value: SliderValue<RANGE>;
+    min: number;
+    max: number;
+    step?: number | number[];
+    onChange?: SliderPropOnChange<RANGE>;
+    onAfterChange?: SliderPropOnChange<RANGE>;
+    containerRef: React.RefObject<HTMLDivElement>;
+    sliderRef: React.RefObject<HTMLDivElement | HTMLButtonElement>;
+    buttonRefs: React.RefObject<HTMLButtonElement>[];
+};
+export type UseSliderValues = {
+    onKeyPress: (e: React.KeyboardEvent, typeButton: ActiveButton) => void;
+    onFocus: (e: React.FocusEvent<HTMLButtonElement> | React.MouseEvent, button: ActiveButton) => void;
+    handlePress: (typeButton: ActiveButton) => void;
+    onSliderClick: React.MouseEventHandler;
+    activeButton: ActiveButton;
+    currentValue: [number] | [number, number];
+    popoverPosition: TrackPosition[];
+};
+export declare const isRangeParams: (params: UseSliderProps<boolean>) => params is UseSliderProps<true>;
+export declare const isNotRangeParams: (params: UseSliderProps<boolean>) => params is UseSliderProps<false>;
+export declare const trackPosition: (event: TouchEvent | MouseEvent) => TrackPosition;
+export declare const getActiveValue: (value: number | [number, number], active: ActiveButton) => number;
+export declare const detectActiveButton: (position: TrackPosition, buttons: React.RefObject<HTMLButtonElement>[]) => ActiveButton;
+export declare const getValidValue: (value: number, min: number, max: number, step?: number | number[]) => number;
+export declare const isValidValue: (value: number, min: number, max: number, step?: number | number[]) => boolean;
+export declare const getValueByPosition: (position: TrackPosition, sliderRef: React.RefObject<HTMLDivElement | HTMLButtonElement>, min: number, max: number, step?: number | number[]) => number;
+export declare const getNewValue: (changedValue: number, currentValue: number | [number, number], step: number | number[], min: number, max: number, activeButton: ActiveButton) => number | [number, number];
+export declare const analyzeDivisionValue: (value: number, step: number | number[], min: number, max: number) => number;
+export declare const valueToString: (value: number | number[] | undefined | null) => string;

package/__internal__/src/components/Slider/useSlider/useSlider.d.ts

@@ -0,0 +1,3 @@
+import { UseSliderProps, UseSliderValues } from './helper';
+export declare const COUNT_STEPS = 250;
+export declare function useSlider<RANGE extends boolean>(props: UseSliderProps<RANGE>): UseSliderValues;

package/__internal__/src/components/Slider/useSliderStationing.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { Line, SliderPropView } from './helper';
+type UseSliderStationing = (value: number | [number, number] | undefined, min: number, max: number, view: SliderPropView, range: boolean | undefined, step: number | number[] | undefined, buttonRefs: [
+    React.RefObject<HTMLButtonElement>,
+    React.RefObject<HTMLButtonElement>
+], sliderLineRef: React.RefObject<HTMLButtonElement | HTMLDivElement>) => {
+    lineSizes: Line[];
+    buttonPositions: number[];
+};
+export declare const getSteps: (step: number | number[], min: number, max: number) => {
+    min: number;
+    max: number;
+}[];
+export declare const useSliderStationing: UseSliderStationing;
+export {};

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

@@ -0,0 +1,5 @@
+import './SnackBar.css';
+import { SnackBarComponent } from './types';
+export declare const cnSnackBar: import("@bem-react/classname").ClassNameFormatter;
+export declare const SnackBar: SnackBarComponent;
+export * from './types';

package/__internal__/src/components/SnackBar/SnackBarActionButton/SnackBarActionButton.d.ts

@@ -0,0 +1,4 @@
+import './SnackBarActionButton.css';
+import React from 'react';
+import { SnackBarActionButtonProps } from '../types';
+export declare const SnackBarActionButton: React.FC<SnackBarActionButtonProps>;

package/__internal__/src/components/SnackBar/SnackBarActionButton/index.d.ts

@@ -0,0 +1 @@
+export * from './SnackBarActionButton';

package/__internal__/src/components/SnackBar/SnackBarItem/SnackBarItem.d.ts

@@ -0,0 +1,6 @@
+import './SnackBarItem.css';
+import React from 'react';
+import { SnackBarItemComponent, SnackBarItemProps } from '../types';
+export declare const cnSnackBarItem: import("@bem-react/classname").ClassNameFormatter;
+export declare const SnackBarItemRender: (props: SnackBarItemProps, ref: React.Ref<HTMLDivElement>) => JSX.Element;
+export declare const SnackBarItem: SnackBarItemComponent;

package/__internal__/src/components/SnackBar/SnackBarItem/index.d.ts

@@ -0,0 +1 @@
+export * from './SnackBarItem';

package/__internal__/src/components/SnackBar/SnackBarLine/SnackBarLine.d.ts

@@ -0,0 +1,4 @@
+import './SnackBarLine.css';
+import React from 'react';
+import { SnackBarTimerProps } from '../types';
+export declare const SnackBarLine: React.FC<Omit<SnackBarTimerProps, 'hidden'>>;

package/__internal__/src/components/SnackBar/SnackBarLine/index.d.ts

@@ -0,0 +1 @@
+export * from './SnackBarLine';

package/__internal__/src/components/SnackBar/SnackBarProgress/SnackBarProgress.d.ts

@@ -0,0 +1,4 @@
+import './SnackBarProgress.css';
+import React from 'react';
+import { SnackBarProgressProps } from '../types';
+export declare const SnackBarProgress: React.FC<SnackBarProgressProps>;