@consta/uikit 5.18.0 → 5.19.0

package/__internal__/src/src/hooks/useChoiceGroupIndexed/useChoiceGroupIndexed.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+type ValueMultiple = number[] | null;
+type ValueNotMultiple<IS_NULLABLE_VALUE> = IS_NULLABLE_VALUE extends true ? number | null : number;
+export type UseChoiceGroupIndexedParams<MULTIPLE extends boolean = false, IS_NULLABLE_VALUE extends boolean = false, EVENT = React.MouseEvent<HTMLDivElement, MouseEvent>> = {
+    value: (MULTIPLE extends true ? ValueMultiple : ValueNotMultiple<IS_NULLABLE_VALUE>) | undefined;
+    multiple: MULTIPLE;
+    callBack: (value: MULTIPLE extends true ? ValueMultiple : ValueNotMultiple<IS_NULLABLE_VALUE>, props: {
+        e: EVENT;
+    }) => void;
+    isNullableValue?: IS_NULLABLE_VALUE;
+};
+export declare function useChoiceGroupIndexed<MULTIPLE extends boolean, IS_NULLABLE_VALUE extends boolean, EVENT>(props: UseChoiceGroupIndexedParams<MULTIPLE, IS_NULLABLE_VALUE, EVENT>): {
+    getOnChange: (index: number) => (e: EVENT) => void;
+    getChecked: (index: number) => boolean;
+};
+export {};

package/__internal__/src/src/hooks/useClickOutside/useClickOutside.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+export type ClickOutsideHandler = (event: MouseEvent) => void;
+type UseClickOutsideProps = {
+    isActive?: boolean | (() => boolean | undefined);
+    ignoreClicksInsideRefs?: ReadonlyArray<RefObject<HTMLElement>>;
+    handler?: ClickOutsideHandler;
+};
+export declare function useClickOutside({ isActive, ignoreClicksInsideRefs, handler, }: UseClickOutsideProps): void;
+export {};

package/__internal__/src/src/hooks/useComponentBreakpointsDeprecated/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useComponentBreakpointsDeprecated';
+export * from '##/hooks/useBreakpoints/getLastPoint';

package/__internal__/src/src/hooks/useComponentBreakpointsDeprecated/useComponentBreakpointsDeprecated.d.ts

@@ -0,0 +1,2 @@
+import { Map, Returned } from '##/hooks/useBreakpoints/types';
+export declare const useComponentBreakpoints: <POINTS extends string>(ref: React.RefObject<HTMLElement | SVGGraphicsElement>, map: Map<POINTS>) => Returned<POINTS>;

package/__internal__/src/src/hooks/useComponentSize/getElementSize.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated use import { getElementSize } from '@consta/uikit/useResizeObserved'
+ */
+export declare const getElementSize: (el: HTMLElement | SVGGraphicsElement | null) => import("##/hooks/useResizeObserved/getElementSize").ComponentSize;

package/__internal__/src/src/hooks/useComponentSize/types.d.ts

@@ -0,0 +1,4 @@
+export type ComponentSize = {
+    width: number;
+    height: number;
+};

package/__internal__/src/src/hooks/useFlag/useFlag.d.ts

@@ -0,0 +1,10 @@
+export type Flag = [
+    boolean,
+    {
+        on: () => void;
+        off: () => void;
+        toggle: () => void;
+        set: React.Dispatch<React.SetStateAction<boolean>>;
+    }
+];
+export declare const useFlag: (initial?: boolean) => Flag;

package/__internal__/src/src/hooks/useForkRef/useForkRef.d.ts

@@ -0,0 +1,2 @@
+export declare const forkRef: <T>(refs: (React.Ref<T> | undefined)[]) => React.RefCallback<T> | null;
+export declare const useForkRef: <T>(refs: (React.Ref<T> | undefined)[]) => ((instance: T | null) => void) | null;

package/__internal__/src/src/hooks/useGlobalKeys/useGlobalKeys.d.ts

@@ -0,0 +1,6 @@
+import { KeyCode } from '##/utils/types/KeyCode';
+export type KeyHandlers = Partial<Record<KeyCode, (e: KeyboardEvent) => void>> & {
+    [key: string]: (e: KeyboardEvent) => void;
+};
+export type EventType = 'keyup' | 'keydown';
+export declare const useGlobalKeys: (keyHandlers: KeyHandlers, eventType?: EventType) => void;

package/__internal__/src/src/hooks/useHideElementsInLine/useHideElementsInLine.d.ts

@@ -0,0 +1,7 @@
+export declare const useHideElementsInLine: <ELEMENT extends HTMLElement = HTMLDivElement, PARENT extends HTMLElement = HTMLDivElement>(length: number, moreIndex?: number, busy?: number, deps?: unknown[]) => {
+    visibleMap: boolean[];
+    elementsRefs: import("react").RefObject<ELEMENT>[];
+    parentRef: import("react").RefObject<PARENT>;
+    elementsSizes: number[];
+    parentSize: number;
+};

package/__internal__/src/src/hooks/useHideElementsInLineDeprecated/useHideElementsInLineDeprecated.d.ts

@@ -0,0 +1,9 @@
+export declare const useHideElementsInLine: <ITEM, ELEMENT extends HTMLElement = HTMLDivElement, WRAPPER_ELEMENT extends HTMLElement = HTMLDivElement>(items: ITEM[], busy?: number, reverse?: boolean) => {
+    visibleItems: ITEM[];
+    hiddenItems: ITEM[];
+    itemsRefs: import("react").RefObject<ELEMENT>[];
+    wrapperRef: import("react").RefObject<WRAPPER_ELEMENT>;
+    moreRef: import("react").RefObject<ELEMENT> | undefined;
+    itemsDimensions: number[];
+    wrapperWidth: number;
+};

package/__internal__/src/src/hooks/useKeys/useKeys.d.ts

@@ -0,0 +1,10 @@
+import { KeyCode } from '##/utils/types/KeyCode';
+export type UseKeysPropKeys<ELEMENT = Element> = Partial<Record<KeyCode, React.KeyboardEventHandler<ELEMENT>>> & {
+    [key: string]: React.KeyboardEventHandler;
+};
+export type UseKeysProps<ELEMENT = Element> = {
+    keys: UseKeysPropKeys<ELEMENT>;
+    onEvent?: React.KeyboardEventHandler<ELEMENT>;
+    isActive: boolean;
+};
+export declare const useKeys: <ELEMENT = Element>(props: UseKeysProps<ELEMENT>) => React.KeyboardEventHandler<ELEMENT>;

package/__internal__/src/src/hooks/useKeysDeprecated/useKeysDeprecated.d.ts

@@ -0,0 +1,17 @@
+export type KeyHandler = (prop: Record<string, unknown>, e: React.KeyboardEvent) => void;
+export type KeyProps = {
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onClick?: (e: React.MouseEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+};
+export type UserKeysProps = {
+    [key: string]: (prop: {
+        keyCode: number;
+        key: string;
+        shift: boolean;
+        meta: boolean;
+    }, e: React.KeyboardEvent<Element>) => void;
+};
+export declare const useKeys: (userKeys: UserKeysProps) => (rest?: KeyProps) => KeyProps;

package/__internal__/src/src/hooks/useKeysRef/useKeysRef.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { KeyCode } from '##/utils/types/KeyCode';
+export type KeyHandlers = Partial<Record<KeyCode, (e: KeyboardEvent) => void>> & {
+    [key: string]: (e: KeyboardEvent) => void;
+};
+type UseKeysProps = {
+    ref?: React.RefObject<HTMLElement>;
+    keys: KeyHandlers;
+    isActive?: boolean | (() => boolean | undefined);
+    eventHandler?: (event: KeyboardEvent) => void;
+    eventType?: 'keypress' | 'keydown' | 'keyup';
+};
+export declare const useKeysRef: (params: UseKeysProps) => void;
+export {};

package/__internal__/src/src/hooks/useMouseLeave/useMouseLeave.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+type Props = {
+    isActive?: boolean;
+    refs: ReadonlyArray<RefObject<HTMLElement>>;
+    handler: (event: FocusEvent) => void;
+    debounce?: number;
+};
+export declare function useMouseLeave({ isActive, refs, handler, debounce, }: Props): void;
+export {};

package/__internal__/src/src/hooks/useMutableRef/useMutableRef.d.ts

@@ -0,0 +1 @@
+export declare const useMutableRef: <T>(value: T) => import("react").MutableRefObject<T>;

package/__internal__/src/src/hooks/useOverflow/useOverflow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    currentRef: React.RefObject<HTMLElement>;
+    containerRef?: React.RefObject<HTMLElement> | Document | Window;
+};
+export declare const useOverflow: (props: Props) => boolean;
+export {};

package/__internal__/src/src/hooks/useRefs/useRefs.d.ts

@@ -0,0 +1,3 @@
+type Return<T, E extends number | string[] | readonly string[]> = E extends string[] ? Record<E[number], React.RefObject<T>> : E extends readonly string[] ? Record<E[number], React.RefObject<T>> : Array<React.RefObject<T>>;
+export declare const useRefs: <T, E extends number | string[] | readonly string[] = number>(elements: E, deps?: unknown[]) => Return<T, E>;
+export {};

package/__internal__/src/src/hooks/useResizableContent/types.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export type UseResizableContentPropDirection = 'vertical' | 'horizontal';
+export type UseResizableContentRef = {
+    ref: React.RefObject<HTMLElement>;
+    maxHeight?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    minWidth?: number;
+};
+export type UseResizableContentSize = {
+    width?: number;
+    height?: number;
+};
+type UseResizableContentProps = {
+    blocks: Array<UseResizableContentRef | React.RefObject<HTMLElement>>;
+    direction?: UseResizableContentPropDirection;
+    container: React.RefObject<HTMLElement>;
+    isActive?: boolean;
+};
+export type UseResizableContent = (props: UseResizableContentProps) => {
+    handlers: Array<{
+        onMouseDown: React.MouseEventHandler;
+        onTouchStart: React.TouchEventHandler;
+    }>;
+    sizes: UseResizableContentSize[];
+};
+export {};

package/__internal__/src/src/hooks/useResizeObserved/getElementSize.d.ts

@@ -0,0 +1,5 @@
+export type ComponentSize = {
+    width: number;
+    height: number;
+};
+export declare const getElementSize: (el: HTMLElement | SVGGraphicsElement | null) => ComponentSize;

package/__internal__/src/src/hooks/useResizeObserved/useResizeObserved.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare const useResizeObserved: <ELEMENT extends HTMLElement | SVGGraphicsElement, RETURN_TYPE>(refs: Array<RefObject<ELEMENT>>, mapper: (el: ELEMENT | null) => RETURN_TYPE) => RETURN_TYPE[];

package/__internal__/src/src/hooks/useScrollElements/useScrollElements.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type UseScrollElementsResult = {
+    refs: React.RefObject<HTMLElement>[];
+    scrollTo: (index: number) => void;
+};
+export declare function useScrollElements<ITEM>(items: ITEM[], containerRef?: React.RefObject<HTMLElement>): UseScrollElementsResult;
+export {};

package/__internal__/src/src/hooks/useScrollPosition/useScrollPosition.d.ts

@@ -0,0 +1,5 @@
+export type ScrollPosition = {
+    scrollLeft: number;
+    scrollTop: number;
+};
+export declare const useScrollPosition: (el: HTMLElement | null) => ScrollPosition;

package/__internal__/src/src/hooks/useSelect/helpers.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+type State = {
+    searchValue: string;
+    resolvedSearchValue: string;
+    isOpen: boolean;
+    highlightedIndex: number;
+    scrollToHighlighted: boolean;
+};
+type Action = string;
+type Updater = (state: State) => State;
+export declare function useHoistedState(initialState: State): [State, (updater: Updater, action: Action) => void];
+type ScrollToIndexFunctionType = (optionIndex: number, dropdownRef: React.MutableRefObject<HTMLDivElement | null>) => void;
+export declare const scrollToIndex: ScrollToIndexFunctionType;
+export {};

package/__internal__/src/src/hooks/useSelect/index.d.ts

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

package/__internal__/src/src/hooks/useSelect/useSelect.d.ts

@@ -0,0 +1,80 @@
+import React from 'react';
+import { CountedGroup, SelectAllItem } from '../../utils/getGroups';
+type IndexForHighlight = number | ((oldIndex: number) => number);
+type Group<ITEM, GROUP> = {
+    items: ITEM[];
+    key: string | number;
+    group?: GROUP;
+};
+type GetItemGroupKey<ITEM> = (item: ITEM) => string | number | undefined;
+type GetGroupKey<GROUP> = (item: GROUP) => string | number | undefined;
+type SortGroups<ITEM, GROUP> = (a: Group<ITEM, GROUP>, b: Group<ITEM, GROUP>) => number;
+type OnChangeProp<ITEM, MULTIPLE extends boolean> = (props: {
+    value: (MULTIPLE extends true ? ITEM[] : ITEM) | null;
+    e: React.SyntheticEvent;
+}) => void;
+type ValueProp<ITEM, MULTIPLE extends boolean> = (MULTIPLE extends true ? ITEM[] : ITEM) | null | undefined;
+export type OptionForCreate = {
+    label: string;
+    __optionForCreate: boolean;
+};
+export type SelectProps<ITEM, GROUP, MULTIPLE extends boolean> = {
+    getItemGroupKey?: GetItemGroupKey<ITEM> | undefined;
+    getGroupKey?: GetGroupKey<GROUP>;
+    sortGroups?: SortGroups<ITEM, GROUP>;
+    groups?: GROUP[];
+    items: ITEM[];
+    dropdownRef: React.MutableRefObject<HTMLDivElement | null>;
+    controlRef: React.MutableRefObject<HTMLDivElement | null>;
+    disabled?: boolean;
+    selectAll?: boolean;
+    getItemLabel: (item: ITEM) => string;
+    getItemKey: (item: ITEM) => string | number;
+    getItemDisabled?: (item: ITEM) => boolean | undefined;
+    searchFunction?: (item: ITEM, searchValue: string) => boolean;
+    onCreate?: (props: {
+        e: React.SyntheticEvent;
+        label: string;
+    }) => void;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    multiple: boolean;
+    searchValue?: string;
+    withoutClearSearch?: boolean;
+    onChange: OnChangeProp<ITEM, MULTIPLE>;
+    value: ValueProp<ITEM, MULTIPLE>;
+};
+export type OptionProps<ITEM> = {
+    index: number;
+    item: ITEM | OptionForCreate | SelectAllItem;
+};
+export type GetOptionPropsResult = {
+    onClick: (e: React.SyntheticEvent) => void;
+    onMouseEnter: (e: React.SyntheticEvent) => void;
+    active: boolean;
+    hovered: boolean;
+    key: string | number;
+};
+export declare const isOptionForCreate: <ITEM, GROUP>(params: OptionForCreate | Group<ITEM, GROUP> | ITEM) => params is OptionForCreate;
+export declare const isOptionForSelectAll: <ITEM, GROUP>(params: SelectAllItem | Group<ITEM, GROUP> | ITEM) => params is SelectAllItem;
+export declare function useSelect<ITEM, GROUP, MULTIPLE extends boolean>(params: SelectProps<ITEM, GROUP, MULTIPLE>): {
+    isOpen: boolean;
+    isFocused: boolean;
+    highlightedIndex: number;
+    visibleItems: (OptionForCreate | CountedGroup<ITEM, GROUP>)[];
+    highlightIndex: (indexForHighlight: IndexForHighlight, scrollToHighlighted: boolean) => void;
+    getOptionProps: ({ index, item, }: OptionProps<ITEM>) => GetOptionPropsResult;
+    handleInputFocus: (e: React.FocusEvent<HTMLInputElement>) => void;
+    handleInputBlur: (e: React.FocusEvent<HTMLInputElement>) => void;
+    handleToggleDropdown: () => void;
+    handleInputClick: () => void;
+    inputRef: React.RefObject<HTMLInputElement>;
+    getKeyProps: (rest?: import("../useKeysDeprecated/useKeysDeprecated").KeyProps) => import("../useKeysDeprecated/useKeysDeprecated").KeyProps;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    searchValue: string;
+    clearValue: (e: React.SyntheticEvent) => void;
+    getHandleRemoveValue: (item: ITEM) => (e: React.SyntheticEvent) => void;
+    notFound: boolean;
+    hasItems: boolean;
+};
+export {};

package/__internal__/src/src/hooks/useSortSteps/useSortSteps.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    step?: string | number | number[];
+    min?: string | number;
+    max?: string | number;
+};
+export declare const useSortSteps: (props: Props) => number | number[];
+export {};

package/__internal__/src/src/hooks/useStyleProps/getStyleProps.d.ts

@@ -0,0 +1,2 @@
+import { Value } from './types';
+export declare const getStyleProps: <StyleProps extends string | string[] | readonly string[] = string>(element: HTMLElement | SVGElement, props: StyleProps) => Value<StyleProps>;

package/__internal__/src/src/hooks/useStyleProps/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const varIsArray: <V extends string | string[] | readonly string[]>(v: V) => v is Exclude<V, string>;
+export declare const varIsString: <V extends string | string[] | readonly string[]>(v: V) => v is Exclude<V, string[] | readonly string[]>;

package/__internal__/src/src/hooks/useStyleProps/types.d.ts

@@ -0,0 +1 @@
+export type Value<V extends string | string[] | readonly string[]> = V extends string[] ? Record<V[number], string> : V extends readonly string[] ? Record<V[number], string> : string;

package/__internal__/src/src/hooks/useStyleProps/useStyleProps.d.ts

@@ -0,0 +1,2 @@
+import { Value } from './types';
+export declare const useStyleProps: <Element extends HTMLElement | SVGElement = HTMLDivElement, StyleProps extends string | string[] | readonly string[] = string>(props: StyleProps) => [React.RefObject<Element>, Value<StyleProps>];

package/__internal__/src/src/hooks/useThemeVars/useThemeVars.d.ts

@@ -0,0 +1,47 @@
+import { defaultVars } from './helpers';
+export type Vars = {
+    readonly color: {
+        readonly primary: readonly string[];
+        readonly accent: readonly string[];
+        readonly invert: readonly string[];
+    };
+    readonly control: readonly string[];
+    readonly font: readonly string[];
+    readonly size: readonly string[];
+    readonly space: readonly string[];
+    readonly shadow: readonly string[];
+};
+export type ThemeVars<T extends Vars = typeof defaultVars> = {
+    color: {
+        primary: {
+            [key in T['color']['primary'][number]]: string;
+        };
+        accent: {
+            [key in T['color']['accent'][number]]: string;
+        };
+        invert: {
+            [key in T['color']['invert'][number]]: string;
+        };
+    };
+    control: {
+        [key in T['control'][number]]: string;
+    };
+    font: {
+        [key in T['font'][number]]: string;
+    };
+    size: {
+        [key in T['size'][number]]: string;
+    };
+    space: {
+        [key in T['space'][number]]: string;
+    };
+    shadow: {
+        [key in T['shadow'][number]]: string;
+    };
+};
+type UseThemeVarsOptions<T> = {
+    vars?: T;
+    deps?: [];
+};
+export declare const useThemeVars: <T extends Vars = typeof defaultVars>(options?: UseThemeVarsOptions<T>) => ThemeVars<T>;
+export {};

package/__internal__/src/src/hooks/useTimer/useTimer.d.ts

@@ -0,0 +1,20 @@
+export type Timer = 'DECREMENTAL' | 'INCREMENTAL';
+export type Config = {
+    /** interval in ms  */
+    interval: number;
+    /**  stop timer in ms */
+    endTime: number | null;
+    /**  start timer in ms */
+    startTime: number;
+    /** timer over callback */
+    onTimeOver?: () => void;
+    timerType: Timer;
+};
+export type Values = {
+    isRunning: boolean;
+    pause: () => void;
+    reset: () => void;
+    start: () => void;
+    time: number;
+};
+export declare function useTimer(config?: Partial<Config>): Values;

package/__internal__/src/src/hooks/useVirtualScroll/helpers.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+export type UseVirtualScrollProps = {
+    length: number;
+    isActive?: boolean;
+    onScrollToBottom?: (index: number) => void;
+};
+export type UseVirtualScrollReturn<ITEM_ELEMENT, SCROLL_ELEMENT> = {
+    listRefs: React.RefObject<ITEM_ELEMENT>[];
+    scrollElementRef: React.RefObject<SCROLL_ELEMENT>;
+    slice: [number, number];
+    spaceTop: number;
+};
+export type Bounds = [[number, number], [number, number]];
+export declare const defaultItemsCalculationCount = 5;
+export declare const arraysIsEq: (arr1: number[], arr2: number[]) => boolean;
+export declare const useScroll: (ref: RefObject<HTMLElement>, fn: () => void, isActive: boolean) => void;
+export declare const getElementHeight: (el: HTMLElement | SVGGraphicsElement | null) => number;
+export declare const getVisiblePosition: (top: number, height: number, elementMaxSize: number) => [number, number];
+export declare const calculateSavedSizes: (savedSizes: number[], sizes: number[]) => number[];
+export declare const useCalculateVisiblePosition: (scrollElement: HTMLElement | null, set: (value: React.SetStateAction<[number, number]>) => void, elementsSizes: number[]) => () => void;
+export declare const calculateBounds: (savedSizes: number[], sizes: number[], visiblePosition: [number, number], length: number) => Bounds;

package/__internal__/src/src/mixs/MixCard/MixCard.d.ts

@@ -0,0 +1,17 @@
+import './MixCard.css';
+type Size = 'xs' | 's' | 'm' | 'l' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
+declare const formMap: readonly ["round", "square"];
+type FormMap = typeof formMap[number];
+declare const cardStatus: readonly ["alert", "success", "warning"];
+type CardStatus = typeof cardStatus[number] | string;
+type Props = {
+    shadow?: boolean;
+    border?: boolean;
+    verticalSpace?: Size;
+    horizontalSpace?: Size;
+    form?: FormMap;
+    status?: CardStatus;
+};
+type CnCard = (props: Props, classNames?: Array<string | undefined>) => string;
+export declare const cnMixCard: CnCard;
+export {};

package/__internal__/src/src/mixs/MixFlex/MixFlex.d.ts

@@ -0,0 +1,24 @@
+import './MixFlex.css';
+import { Space } from '../MixSpace';
+export declare const mixFlexPropAlign: readonly ["flex-start", "flex-end", "center", "baseline", "stretch"];
+export type MixFlexPropAlign = typeof mixFlexPropAlign[number];
+export declare const mixFlexPropJustify: readonly ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly"];
+export type MixFlexPropJustify = typeof mixFlexPropJustify[number];
+export declare const mixFlexPropFlex: readonly ["flex", "inline-flex"];
+export type MixFlexPropFlex = typeof mixFlexPropFlex[number];
+export declare const mixFlexPropWrap: readonly ["nowrap", "wrap", "wrap-reverse"];
+export type MixFlexPropWrap = typeof mixFlexPropWrap[number];
+export declare const mixFlexPropDirection: readonly ["row", "row-reverse", "column", "column-reverse"];
+export type MixFlexPropDirection = typeof mixFlexPropDirection[number];
+type Props = {
+    align?: MixFlexPropAlign;
+    justify?: MixFlexPropJustify;
+    flex?: MixFlexPropFlex;
+    wrap?: MixFlexPropWrap;
+    direction?: MixFlexPropDirection;
+    gap?: Space;
+    order?: -1 | 0 | 1;
+};
+type CnMixFlex = (props: Props, classNames?: Array<string | undefined>) => string;
+export declare const cnMixFlex: CnMixFlex;
+export {};

package/__internal__/src/src/mixs/MixHitSlop/MixHitSlop.d.ts

@@ -0,0 +1,6 @@
+import './MixHitSlop.css';
+type CnMixHitSlop = (props: {
+    mode: 'before' | 'after' | 'reverseMargin';
+}) => string;
+export declare const cnMixHitSlop: CnMixHitSlop;
+export {};

package/__internal__/src/src/mixs/MixPopoverAnimate/MixPopoverAnimate.d.ts

@@ -0,0 +1,12 @@
+import './MixPopoverAnimate.css';
+import { Direction } from '../../components/Popover/Popover';
+export type Animate = 'entered' | 'entering' | 'exiting' | 'exited' | 'unmounted' | 'enter' | 'enterActive' | 'enterDone' | 'exit' | 'exitActive' | 'exitDone';
+type Mods = {
+    animate?: Animate;
+    direction?: Direction;
+};
+type CnMixPopoverAnimate = (mods?: Mods | null, mix?: Array<string | undefined>) => string;
+export declare const cnMixPopoverAnimate: CnMixPopoverAnimate;
+export declare const cnMixPopoverAnimateForCssTransition: import("../../utils/cnForCssTransition").CSSTransitionClassNames;
+export declare const animateTimeout = 200;
+export {};

package/__internal__/src/src/mixs/MixPopoverArrow/MixPopoverArrow.d.ts

@@ -0,0 +1,8 @@
+import './MixPopoverArrow.css';
+import { Direction } from '../../components/Popover/Popover';
+type Props = {
+    direction?: Direction;
+};
+type CnMixPopoverArrow = (elemNameOrBlockMods?: Props | string | null, elemModsOrBlockMix?: Props | Array<string | undefined> | null, elemMix?: Array<string | undefined>) => string;
+export declare const cnMixPopoverArrow: CnMixPopoverArrow;
+export {};

package/__internal__/src/src/mixs/MixScrollBar/MixScrollBar.d.ts

@@ -0,0 +1,15 @@
+import './MixScrollBar.css';
+export declare const mixScrollBarPropSize: readonly ["m", "xs", "s"];
+export type MixScrollBarPropSize = typeof mixScrollBarPropSize[number];
+export declare const mixScrollBarPropSizeDefault: MixScrollBarPropSize;
+export declare const mixScrollBarPropTrackSize: readonly ["auto", "native"];
+export type MixScrollBarPropTrackSize = typeof mixScrollBarPropTrackSize[number];
+export declare const mixScrollBarPropTrackSizeDefault: MixScrollBarPropTrackSize;
+type MixScrollBarProps = {
+    size?: MixScrollBarPropSize;
+    invisible?: boolean;
+    trackSize?: MixScrollBarPropTrackSize;
+};
+type CnMixScrollBar = (props?: MixScrollBarProps) => string;
+export declare const cnMixScrollBar: CnMixScrollBar;
+export {};

package/__internal__/src/src/mixs/MixSpace/MixSpace.d.ts

@@ -0,0 +1,5 @@
+import './MixSpace.css';
+import { MixSpaceProps } from './types';
+type CnMixSpace = (props: MixSpaceProps) => string;
+export declare const cnMixSpace: CnMixSpace;
+export {};

package/__internal__/src/src/mixs/MixSpace/types.d.ts

@@ -0,0 +1,17 @@
+export type Space = 0 | 'auto' | 'm' | '3xs' | '2xs' | 'xs' | 's' | 'l' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl';
+export type MixSpaceProps = {
+    p?: Space;
+    m?: Space;
+    pV?: Space;
+    pH?: Space;
+    mV?: Space;
+    mH?: Space;
+    mT?: Space;
+    mL?: Space;
+    mR?: Space;
+    mB?: Space;
+    pT?: Space;
+    pL?: Space;
+    pR?: Space;
+    pB?: Space;
+};

package/__internal__/src/src/responsesImages/ResponsesImage/ResponsesImage.d.ts

@@ -0,0 +1,6 @@
+import './ResponsesImage.css';
+import React from 'react';
+import { PropsWithHTMLAttributes } from '../../utils/types/PropsWithHTMLAttributes';
+export type ResponsesImageProps = PropsWithHTMLAttributes<{}, HTMLDivElement>;
+export declare const cnResponsesImage: import("@bem-react/classname").ClassNameFormatter;
+export declare const ResponsesImage: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "css"> & React.RefAttributes<HTMLDivElement>>;

package/__internal__/src/src/responsesImages/ResponsesImage403/ResponsesImage403.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImage403: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImage404/ResponsesImage404.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImage404: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImage500/ResponsesImage500.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImage500: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImage503/ResponsesImage503.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImage503: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageConnectionError/ResponsesImageConnectionError.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageConnectionError: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageDeleted/ResponsesImageDeleted.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageDeleted: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageEmptyBox/ResponsesImageEmptyBox.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageEmptyBox: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageEmptyPockets/ResponsesImageEmptyPockets.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageEmptyPockets: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageExit/ResponsesImageExit.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageExit: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageNothingFound/ResponsesImageNothingFound.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageNothingFound: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/ResponsesImageSuccess/ResponsesImageSuccess.d.ts

@@ -0,0 +1 @@
+export declare const ResponsesImageSuccess: import("react").FC<Omit<import("react").HTMLAttributes<HTMLDivElement>, "css">>;

package/__internal__/src/src/responsesImages/createResponsesImage/createResponsesImage.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type ImageComponent = React.FC<React.SVGProps<SVGSVGElement>>;
+type CreateResponsesImageArguments = {
+    name: string;
+    component: ImageComponent;
+};
+export declare function createResponsesImage({ name, component: Svg, }: CreateResponsesImageArguments): React.FC<Omit<React.HTMLAttributes<HTMLDivElement>, "css">>;
+export {};

package/__internal__/src/src/stand/standConfig.d.ts

@@ -0,0 +1 @@
+export declare const createStand: (standProps: Stand<GROUP["id"]>) => CreatedStand;