@reportportal/ui-kit 0.0.1-alpha.13 → 0.0.1-alpha.130

package/dist/components/autocompletes/multipleAutocomplete/multipleAutocomplete.d.ts

@@ -0,0 +1,49 @@
+import { ComponentProps, ReactNode } from 'react';
+import { ControllerStateAndHelpers } from 'downshift';
+import { default as FieldText } from '../../fieldText';
+import { AutocompleteMenu } from '../common/autocompleteMenu';
+import { DownshiftStore, MultipleDownshiftProps } from './multipleDownshift';
+import { GetItemPropsT } from '../types';
+
+export interface MultipleAutocompleteProps<T> {
+    options: T[];
+    loading: boolean;
+    onStateChange: MultipleDownshiftProps<T>['onStateChange'];
+    value: T[];
+    placeholder: string;
+    error: string | boolean;
+    touched: boolean;
+    creatable: boolean;
+    editable: boolean;
+    renderOption?: (value: T, index: number, isNew: boolean, getItemProps: GetItemPropsT<T>) => ReactNode;
+    onChange: (selectedItems: T | T[] | null, downshift: ControllerStateAndHelpers<T> | null) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    disabled: boolean;
+    mobileDisabled: boolean;
+    inputProps: ComponentProps<typeof FieldText>;
+    parseValueToString: (value: T | null) => string;
+    minLength?: number | null;
+    maxLength?: number | null;
+    async?: boolean;
+    customClass: string;
+    createWithoutConfirmation: boolean;
+    getItemValidationErrorType?: (item: T) => string;
+    clearItemsError: () => void;
+    isDropdownMode?: boolean;
+    getAdditionalCreationCondition: (value: string) => boolean;
+    highlightUnStoredItem: boolean;
+    parseInputValueFn: ((value: string) => T[]) | null;
+    handleUnStoredItemCb: ((newSelectedItems: DownshiftStore<T>, prevSelectedItems: DownshiftStore<T>) => void) | null;
+    dataAutomationId?: string;
+    existingItemsMap: Record<string | number, boolean>;
+    optionVariant: ComponentProps<typeof AutocompleteMenu>['optionVariant'];
+    customizeNewSelectedValue: (value: T) => T;
+    renderCustomSelectedItem?: (item: T) => ReactNode;
+    getUniqKey?: (item: T) => string;
+    customEmptyListMessage?: string;
+    customNoMatchesMessage?: string;
+    useFixedPositioning?: boolean;
+    newItemButtonText?: string;
+}
+export declare const MultipleAutocomplete: <T>(componentsProps: MultipleAutocompleteProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/autocompletes/multipleAutocomplete/multipleDownshift.d.ts

@@ -0,0 +1,25 @@
+import { ControllerStateAndHelpers, DownshiftProps } from 'downshift';
+
+export type DownshiftStore<T> = {
+    [key: string]: boolean;
+} | T[];
+export interface MultipleDownshiftProps<T> extends Partial<DownshiftProps<T>> {
+    options: T[];
+    selectedItems: T[];
+    handleUnStoredItemCb: ((newSelectedItems: DownshiftStore<T>, prevSelectedItems: DownshiftStore<T>) => void) | null;
+    existingItemsMap: {
+        [key: string]: boolean;
+    };
+    customizeNewSelectedValue: (value: T) => T;
+    getOptionUniqKey?: (option: T) => keyof T;
+    getOptionUniqKeyValue?: (option: T) => string;
+    onChange: (selectedItems: T | T[] | null, downshift: ControllerStateAndHelpers<T> | null) => void;
+}
+export type GetStateAndHelpersT<T> = ControllerStateAndHelpers<T> & {
+    removeItem: (removedItem: T, downshift: ControllerStateAndHelpers<T> | null) => void;
+    editItem: (oldItem: T, newValue: string) => void;
+    handleChange: MultipleDownshiftProps<T>['onChange'];
+    getOptionUniqKeyValue?: (option: T) => string;
+    storedItemsMap: MultipleDownshiftProps<T>['existingItemsMap'];
+};
+export declare const MultipleDownshift: <T>({ options, onChange, selectedItems, handleUnStoredItemCb, existingItemsMap, children, customizeNewSelectedValue, getOptionUniqKey, getOptionUniqKeyValue, ...props }: MultipleDownshiftProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/autocompletes/multipleAutocomplete/selectedItems/index.d.ts

@@ -0,0 +1 @@
+export { SelectedItems } from './selectedItems';

package/dist/components/autocompletes/multipleAutocomplete/selectedItems/selectedItems.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+
+type VariantType = 'light' | 'dark';
+interface SelectedItemProps<T> {
+    item: T;
+    onRemoveItem: (item: T) => void;
+    parseValueToString?: (value: T) => string;
+    editItem: (oldItem: T, newValue: string) => void;
+    disabled?: boolean;
+    mobileDisabled?: boolean;
+    error?: string | boolean;
+    editable?: boolean;
+    getAdditionalCreationCondition?: (value: string) => boolean;
+    storedOption?: boolean;
+    highlightUnStoredItem?: boolean;
+    variant?: VariantType;
+    getItemName?: (item: T) => string;
+    changeItemHandler?: (item: T, value: string) => T;
+}
+type SelectedItemsProps<T> = Omit<SelectedItemProps<T>, 'item' | 'editItem'> & {
+    items?: T[];
+    onRemoveItem?: (item: T) => void;
+    parseValueToString: (value: T | null) => string;
+    editItem: (oldItem: T, newValue: string) => void;
+    disabled?: boolean;
+    mobileDisabled?: boolean;
+    storedItemsMap?: Record<string, boolean>;
+    highlightUnStoredItem?: boolean;
+    editable?: boolean;
+    variant?: VariantType;
+    getItemValidationErrorType?: ((item: T) => string) | null;
+    renderCustomSelectedItem?: (item: T) => ReactNode;
+};
+export declare const SelectedItems: <T>({ items, parseValueToString, getItemValidationErrorType, storedItemsMap, highlightUnStoredItem, renderCustomSelectedItem, ...props }: SelectedItemsProps<T>) => (string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | null | undefined)[];
+export {};

package/dist/components/autocompletes/singleAutocomplete/index.d.ts

@@ -0,0 +1 @@
+export { SingleAutocomplete } from './singleAutocomplete';

package/dist/components/autocompletes/singleAutocomplete/singleAutocomplete.d.ts

@@ -0,0 +1,42 @@
+import { ComponentProps, FocusEvent, ReactNode, Ref } from 'react';
+import { default as Downshift, DownshiftState, StateChangeOptions } from 'downshift';
+import { default as FieldText } from '../../fieldText';
+import { AutocompleteMenu } from '../common/autocompleteMenu';
+import { GetItemPropsT } from '../types';
+
+export interface SingleAutocompleteProps<T> {
+    options: T[];
+    loading?: boolean;
+    onStateChange: ComponentProps<typeof Downshift<T>>['onStateChange'];
+    value: T | null;
+    placeholder: string;
+    onChange: ComponentProps<typeof Downshift<T>>['onChange'];
+    onFocus: () => void;
+    onBlur: (e: FocusEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    inputProps?: ComponentProps<typeof FieldText>;
+    parseValueToString: (value: T | null) => string;
+    renderOption?: (value: T, index: number, isNew: boolean, getItemProps: GetItemPropsT<T>) => ReactNode;
+    minLength?: number;
+    maxLength?: number | null;
+    async?: boolean;
+    optionVariant?: ComponentProps<typeof AutocompleteMenu>['optionVariant'];
+    isRequired?: boolean;
+    error: string;
+    touched?: boolean;
+    setTouch?: (value: boolean) => void;
+    createWithoutConfirmation: boolean;
+    menuClassName?: string;
+    icon?: ReactNode;
+    isDropdownMode?: boolean;
+    skipOptionCreation?: boolean;
+    isOptionUnique?: (value: boolean | null) => void;
+    refFunction?: Ref<HTMLInputElement>;
+    stateReducer?: (state: DownshiftState<T>, changes: StateChangeOptions<T>) => Partial<StateChangeOptions<T>>;
+    useFixedPositioning: boolean;
+    getUniqKey?: (item: T) => string;
+    customEmptyListMessage?: string;
+    customNoMatchesMessage?: string;
+    newItemButtonText?: string;
+}
+export declare const SingleAutocomplete: <T>(componentProps: SingleAutocompleteProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/autocompletes/types.d.ts

@@ -0,0 +1,8 @@
+import { GetItemPropsOptions } from 'downshift';
+
+export type GetOptionUniqKeyT<T> = (value: T) => keyof T;
+export interface AdditionalDownshiftFields {
+    isActive?: boolean;
+}
+export type OptionVariant = 'light' | 'dark' | string;
+export type GetItemPropsT<T> = (args: GetItemPropsOptions<T> & AdditionalDownshiftFields) => GetItemPropsOptions<T> & AdditionalDownshiftFields;

package/dist/components/autocompletes/utils.d.ts

@@ -0,0 +1,5 @@
+import { GetOptionUniqKeyT } from './types';
+
+export declare const getUniqKey: <T>(option: T, getOptionUniqKey?: GetOptionUniqKeyT<T>) => string;
+export declare const isEqual: <T>(option: T, item: T) => boolean;
+export declare const compareOptionWithItem: <T>(option: T, item: T, getUniqKeyCb?: GetOptionUniqKeyT<T>) => boolean;

package/dist/components/{icons/baseIconButton → baseIconButton}/baseIconButton.d.ts

@@ -1,4 +1,5 @@
 import { FC, MouseEventHandler, ReactNode, HTMLAttributes } from 'react';
+
 export interface BaseIconButtonProps extends HTMLAttributes<HTMLButtonElement> {
     children: ReactNode;
     className?: string;

package/dist/components/{icons/baseIconButton → baseIconButton}/index.d.ts

@@ -1,4 +1,5 @@
 import { BaseIconButton, BaseIconButtonProps } from './baseIconButton';
+
 export { BaseIconButton };
 export type { BaseIconButtonProps };
 export default BaseIconButton;

package/dist/components/breadcrumbs/breadcrumb/breadcrumb.d.ts

@@ -0,0 +1,10 @@
+import { BreadcrumbDescriptor } from '../types';
+
+interface BreadcrumbProps {
+    descriptor: BreadcrumbDescriptor;
+    titleTailNumChars?: number;
+    isClickable?: boolean;
+    variant?: 'default' | 'dark';
+}
+export declare const Breadcrumb: React.FC<BreadcrumbProps>;
+export {};

package/dist/components/breadcrumbs/breadcrumb/index.d.ts

@@ -0,0 +1 @@
+export { Breadcrumb } from './breadcrumb';

package/dist/components/breadcrumbs/breadcrumbs.d.ts

@@ -0,0 +1,3 @@
+import { BreadcrumbsProps } from './types';
+
+export declare const Breadcrumbs: ({ descriptors, dataAutomationId, LinkComponent, tree, isBackButton, }: BreadcrumbsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/breadcrumbs/breadcrumbsProvider/breadcrumbsProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { LinkComponentType } from '../types';
+
+export interface BreadcrumbsContextValue {
+    LinkComponent?: LinkComponentType;
+}
+export declare const BreadcrumbsContext: import('react').Context<BreadcrumbsContextValue | undefined>;
+interface BreadcrumbsProviderProps {
+    children: ReactNode;
+    LinkComponent?: LinkComponentType;
+}
+export declare const BreadcrumbsProvider: ({ children, LinkComponent }: BreadcrumbsProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/breadcrumbs/breadcrumbsProvider/hooks.d.ts

@@ -0,0 +1,3 @@
+import { BreadcrumbsContextValue } from './breadcrumbsProvider';
+
+export declare const useBreadcrumbsContext: () => BreadcrumbsContextValue;

package/dist/components/breadcrumbs/breadcrumbsProvider/index.d.ts

@@ -0,0 +1 @@
+export { BreadcrumbsProvider } from './breadcrumbsProvider';

package/dist/components/breadcrumbs/hiddenBreadcrumbs/hiddenBreadcrumbs.d.ts

@@ -0,0 +1,6 @@
+import { BreadcrumbDescriptor } from '../types';
+
+export interface HiddenBreadcrumbsProps {
+    descriptors: BreadcrumbDescriptor[];
+}
+export declare const HiddenBreadcrumbs: ({ descriptors }: HiddenBreadcrumbsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/breadcrumbs/hiddenBreadcrumbs/index.d.ts

@@ -0,0 +1,2 @@
+export { HiddenBreadcrumbs } from './hiddenBreadcrumbs';
+export type { HiddenBreadcrumbsProps } from './hiddenBreadcrumbs';

package/dist/components/breadcrumbs/index.d.ts

@@ -0,0 +1,5 @@
+import { Breadcrumbs } from './breadcrumbs';
+
+export { Breadcrumbs };
+export type { BreadcrumbDescriptor, TreeDescriptor, LinkComponentType, BreadcrumbsProps, } from './types';
+export default Breadcrumbs;

package/dist/components/breadcrumbs/tree/index.d.ts

@@ -0,0 +1 @@
+export { Tree } from './tree';

package/dist/components/breadcrumbs/tree/tree.d.ts

@@ -0,0 +1,7 @@
+import { TreeDescriptor } from '../types';
+
+interface TreeProps {
+    tree: TreeDescriptor[];
+}
+export declare const Tree: ({ tree }: TreeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/breadcrumbs/types.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+
+export interface BreadcrumbDescriptor {
+    title: string | ReactNode;
+    link?: object | string;
+    onClick?: () => void;
+}
+export interface TreeDescriptor extends BreadcrumbDescriptor {
+    link: object | string;
+    children?: TreeDescriptor[];
+}
+export type LinkComponentType = React.ComponentType<{
+    to: object | string;
+    className?: string;
+    onClick?: () => void;
+    children: React.ReactNode;
+}>;
+export interface BreadcrumbsProps {
+    descriptors: BreadcrumbDescriptor[];
+    LinkComponent?: LinkComponentType;
+    tree?: TreeDescriptor[];
+    dataAutomationId?: string;
+    isBackButton?: boolean;
+}

package/dist/components/bubblesLoader/bubblesLoader.d.ts

@@ -1,7 +1,9 @@
 import { FC } from 'react';
+
 interface BubblesLoaderProps {
     color?: string;
     className?: string;
+    variant?: 'standard' | 'large';
 }
 export declare const BubblesLoader: FC<BubblesLoaderProps>;
 export {};

package/dist/components/bubblesLoader/index.d.ts

@@ -1,3 +1,4 @@
 import { BubblesLoader } from './bubblesLoader';
+
 export { BubblesLoader };
 export default BubblesLoader;

package/dist/components/button/button.d.ts

@@ -1,7 +1,8 @@
-import { FC, ReactNode, ComponentPropsWithRef, MouseEventHandler } from 'react';
+import { ReactNode, ComponentPropsWithRef, MouseEventHandler } from 'react';
+
 type IconPlace = 'start' | 'end';
-type ButtonVariant = 'primary' | 'ghost' | 'danger' | 'text';
-type ButtonWidth = 'content' | 'wide-content' | 'parent';
+type ButtonVariant = 'primary' | 'ghost' | 'danger' | 'text' | 'ghost-danger' | 'text-danger';
+type ButtonWidth = 'content' | 'wide-content' | 'parent' | 'min-width';
 export interface ButtonProps extends ComponentPropsWithRef<'button'> {
     children?: ReactNode;
     icon?: ReactNode;
@@ -14,5 +15,5 @@ export interface ButtonProps extends ComponentPropsWithRef<'button'> {
     className?: string;
     variant?: ButtonVariant;
 }
-export declare const Button: FC<ButtonProps>;
+export declare const Button: (props: ButtonProps & import('react').RefAttributes<HTMLButtonElement>) => import('react').ReactElement<any, string | import('react').JSXElementConstructor<any>> | null;
 export {};

package/dist/components/button/index.d.ts

@@ -1,4 +1,5 @@
 import { Button, ButtonProps } from './button';
+
 export { Button };
 export type { ButtonProps };
 export default Button;

package/dist/components/checkbox/checkbox.d.ts

@@ -1,6 +1,7 @@
 import { FC, ReactNode, ChangeEventHandler, HTMLAttributes } from 'react';
+
 interface CheckboxProps extends HTMLAttributes<HTMLInputElement> {
-    value: boolean;
+    value?: boolean;
     children?: ReactNode;
     disabled?: boolean;
     className?: string;

package/dist/components/checkbox/index.d.ts

@@ -1,3 +1,4 @@
 import { Checkbox } from './checkbox';
+
 export { Checkbox };
 export default Checkbox;

package/dist/components/datePicker/datePicker.d.ts

@@ -0,0 +1,25 @@
+import { FC, ReactNode, ReactElement } from 'react';
+
+interface DatePickerProps {
+    onChange?: (date: Date | any) => void;
+    onBlur?: () => void;
+    onFocus?: () => void;
+    headerNodes?: ReactNode;
+    disabled?: boolean;
+    shouldCloseOnSelect?: boolean;
+    fixedHeight?: boolean;
+    startDate?: Date | undefined;
+    endDate?: Date | undefined;
+    customClassName?: string;
+    popperClassName?: string;
+    calendarClassName?: string;
+    customTimeInput?: ReactElement;
+    language?: string;
+    yearsOptions?: number[];
+    placeholder?: string;
+    dateFormat?: string;
+    selects?: 'start' | 'end' | 'none';
+    value?: Date | null;
+}
+export declare const DatePicker: FC<DatePickerProps>;
+export {};

package/dist/components/datePicker/header/datePickerHeader.d.ts

@@ -0,0 +1,16 @@
+import { FC, ReactNode } from 'react';
+
+export interface DatePickerHeaderProps {
+    changeYear: (year: number) => void;
+    changeMonth: (month: number) => void;
+    decreaseMonth: () => void;
+    increaseMonth: () => void;
+    headerNodes: ReactNode;
+    date: Date;
+    prevMonthButtonDisabled: boolean;
+    nextMonthButtonDisabled: boolean;
+    customClassName: string;
+    yearsOptions: number[];
+    locale: string;
+}
+export declare const DatePickerHeader: FC<DatePickerHeaderProps>;

package/dist/components/datePicker/header/index.d.ts

@@ -0,0 +1,4 @@
+import { DatePickerHeader } from './datePickerHeader';
+
+export { DatePickerHeader };
+export default DatePickerHeader;

package/dist/components/datePicker/index.d.ts

@@ -0,0 +1,5 @@
+import { DatePicker } from './datePicker';
+import { registerDatePickerLocale } from './utils';
+
+export { DatePicker, registerDatePickerLocale };
+export default DatePicker;

package/dist/components/datePicker/utils.d.ts

@@ -0,0 +1,4 @@
+import { Locale } from 'date-fns';
+
+export declare const registerDatePickerLocale: (language: string, locale: Locale) => void;
+export declare const getYearsFrom: (start: number, amountYearsToGenerate?: number) => number[];

package/dist/components/dropdown/constants.d.ts

@@ -1,7 +1,10 @@
 import { KeyCodes } from '../../common/constants/keyCodes';
+
 export declare const OPEN_DROPDOWN_KEY_CODES: KeyCodes[];
 export declare const CLOSE_DROPDOWN_KEY_CODES: KeyCodes[];
 export declare enum EventName {
     ON_KEY_DOWN = "onKeyDown",
     ON_CLICK = "onClick"
 }
+export declare const SCROLLBARS_AUTO_HEIGHT_MAX = 216;
+export declare const DROPDOWN_PORTAL_MENU_ATTR = "data-dropdown-portal-menu";

package/dist/components/dropdown/dropdown.d.ts

@@ -1,8 +1,9 @@
 import { ReactNode, FC } from 'react';
 import { DropdownVariant, RenderDropdownOption, DropdownOptionType, DropdownValue } from './types';
-interface DropdownProps {
+
+export interface DropdownProps {
     options: DropdownOptionType[];
-    value: DropdownValue;
+    value: DropdownValue | DropdownValue[];
     disabled?: boolean;
     error?: string;
     mobileDisabled?: boolean;
@@ -14,10 +15,41 @@ interface DropdownProps {
     transparentBackground?: boolean;
     className?: string;
     toggleButtonClassName?: string;
-    onChange: (value: DropdownValue) => void;
+    selectListClassName?: string;
+    label?: ReactNode;
+    onChange: (value: DropdownValue | DropdownValue[]) => void;
     onFocus?: () => void;
     onBlur?: () => void;
     renderOption?: RenderDropdownOption;
+    isListWidthLimited?: boolean;
+    multiSelect?: boolean;
+    optionAll?: DropdownOptionType;
+    isOptionAllVisible?: boolean;
+    onSelectAll?: () => void;
+    formatDisplayedValue?: (value: string | undefined) => string;
+    notScrollable?: boolean;
+    footer?: ReactNode | ((closeHandler: () => void) => ReactNode);
+    /**
+     * For nested options: whether to include parent group values in the onChange callback
+     * when all children are selected. Default: false (only leaf values are included)
+     */
+    includeGroupValue?: boolean;
+    /** Whether to show a clear button to reset the selection */
+    clearable?: boolean;
+    /** Callback fired when the clear button is clicked */
+    onClear?: () => void;
+    /** ARIA label for the clear button */
+    clearButtonAriaLabel?: string;
+    /** Portal root element for tooltip rendering (e.g., document.body to prevent clipping) */
+    tooltipPortalRoot?: Element;
+    /** Z-index for tooltip when rendered in portal (default: 9) */
+    tooltipZIndex?: number;
+    /**
+     * Portal root element for dropdown menu rendering.
+     * When provided, the menu will be rendered in this element using React Portal.
+     * Useful for preventing clipping in containers with overflow: hidden (e.g., Modal, SidePanel).
+     * @example menuPortalRoot={document.body}
+     */
+    menuPortalRoot?: Element;
 }
 export declare const Dropdown: FC<DropdownProps>;
-export {};

package/dist/components/dropdown/dropdownOption/dropdownOption.d.ts

@@ -1,3 +1,4 @@
 import { FC } from 'react';
 import { DropdownOptionProps } from '../types';
+
 export declare const DropdownOption: FC<DropdownOptionProps>;

package/dist/components/dropdown/dropdownOption/index.d.ts

@@ -1,3 +1,4 @@
 import { DropdownOption } from './dropdownOption';
+
 export { DropdownOption };
 export default DropdownOption;

package/dist/components/dropdown/index.d.ts

@@ -1,3 +1,5 @@
 import { Dropdown } from './dropdown';
+
 export { Dropdown };
+export { DROPDOWN_PORTAL_MENU_ATTR } from './constants';
 export default Dropdown;

package/dist/components/dropdown/types.d.ts

@@ -1,4 +1,5 @@
 import { MouseEventHandler, ReactNode } from 'react';
+
 export type DropdownVariant = 'default' | 'ghost';
 export type DropdownValue = string | boolean | number;
 export type RenderDropdownOption = (props: DropdownOptionProps) => ReactNode;
@@ -9,6 +10,7 @@ export type DropdownOptionType = {
     hidden?: boolean;
     title?: string;
     groupRef?: string;
+    children?: DropdownOptionType[];
 };
 export interface DropdownOptionProps {
     selected?: boolean;
@@ -16,5 +18,14 @@ export interface DropdownOptionProps {
     highlightHovered?: boolean;
     render?: RenderDropdownOption;
     onMouseEnter?: MouseEventHandler<HTMLDivElement>;
+    multiSelect?: boolean;
+    isPartiallyChecked?: boolean;
+    depth?: number;
+    hasChildren?: boolean;
     option: DropdownOptionType;
 }
+export type FlattenedDropdownOption = {
+    option: DropdownOptionType;
+    depth: number;
+    parent?: DropdownOptionType;
+};

package/dist/components/dropdown/utils.d.ts

@@ -1,4 +1,8 @@
-import { DropdownValue, DropdownOptionType } from './types';
-export declare const calculateDefaultIndex: (options: DropdownOptionType[], selectedValue: DropdownValue) => number;
+import { DropdownValue, DropdownOptionType, FlattenedDropdownOption } from './types';
+
+export declare const calculateDefaultIndex: (options: DropdownOptionType[], selectedValue: DropdownValue | DropdownValue[]) => number;
 export declare const calculateNextIndex: (options: DropdownOptionType[], index?: number) => number;
 export declare const calculatePrevIndex: (options: DropdownOptionType[], index?: number) => number;
+export declare const flattenOptions: (options: DropdownOptionType[], depth?: number, parent?: DropdownOptionType) => FlattenedDropdownOption[];
+export declare const getLeafOptions: (options: DropdownOptionType[]) => DropdownOptionType[];
+export declare const getOptionLeafValues: (option: DropdownOptionType) => DropdownValue[];

package/dist/components/fieldLabel/fieldLabel.d.ts

@@ -0,0 +1,7 @@
+import { DetailedHTMLProps, LabelHTMLAttributes } from 'react';
+
+interface FieldLabelProps extends DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement> {
+    isRequired?: boolean;
+}
+export declare const FieldLabel: ({ children, isRequired, className, ...rest }: FieldLabelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/fieldLabel/index.d.ts

@@ -0,0 +1 @@
+export { FieldLabel } from './fieldLabel';

package/dist/components/fieldNumber/constants.d.ts

@@ -1,4 +1,5 @@
 import { KeyCodes } from '../../common/constants/keyCodes';
+
 export declare const DEFAULT_WIDTH_CH = 5;
 export declare const MAX_WIDTH_CH = 16;
 export declare const ALLOWED_KEY_CODES: KeyCodes[];

package/dist/components/fieldNumber/fieldNumber.d.ts

@@ -1,4 +1,5 @@
-import { FC, HTMLAttributes, FocusEventHandler } from 'react';
+import { HTMLAttributes, FocusEventHandler } from 'react';
+
 type FieldNumberValue = number | string;
 interface FieldNumberProps extends Omit<HTMLAttributes<HTMLInputElement>, 'onChange' | 'onFocus'> {
     onChange: (value: number | string) => void;
@@ -11,8 +12,7 @@ interface FieldNumberProps extends Omit<HTMLAttributes<HTMLInputElement>, 'onCha
     max?: number;
     title?: string;
     error?: string;
-    touched?: boolean;
     onFocus?: () => void | FocusEventHandler<HTMLInputElement>;
 }
-export declare const FieldNumber: FC<FieldNumberProps>;
+export declare const FieldNumber: ({ value, placeholder, disabled, onChange, onFocus, onBlur, label, postfix, min, max, title, error, id, ...rest }: FieldNumberProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/fieldNumber/index.d.ts

@@ -1,3 +1,4 @@
 import { FieldNumber } from './fieldNumber.js';
+
 export { FieldNumber };
 export default FieldNumber;

package/dist/components/fieldText/fieldText.d.ts

@@ -1,11 +1,16 @@
-import { FC, ChangeEventHandler, ReactNode, ComponentPropsWithRef } from 'react';
-interface FieldTextProps extends ComponentPropsWithRef<'input'> {
+import { ChangeEventHandler, ReactElement, ReactNode, InputHTMLAttributes } from 'react';
+
+type InputType = 'password' | 'text' | 'email';
+export interface FieldTextProps extends InputHTMLAttributes<HTMLInputElement> {
     value?: string;
     className?: string;
+    classNameHelpText?: string;
     error?: string;
     placeholder?: string;
     disabled?: boolean;
     onChange?: ChangeEventHandler<HTMLInputElement>;
+    onFocus?: ChangeEventHandler<HTMLInputElement>;
+    onBlur?: ChangeEventHandler<HTMLInputElement>;
     touched?: boolean;
     title?: string;
     label?: string;
@@ -17,8 +22,11 @@ interface FieldTextProps extends ComponentPropsWithRef<'input'> {
     onClear?: (prevValue?: string) => void;
     isRequired?: boolean;
     hasDoubleMessage?: boolean;
-    type?: string;
+    type?: InputType;
     displayError?: boolean;
+    maxLengthDisplay?: number;
+    collapsible?: boolean;
+    loading?: boolean;
 }
-export declare const FieldText: FC<FieldTextProps>;
+export declare const FieldText: (props: FieldTextProps & import('react').RefAttributes<HTMLInputElement>) => ReactElement<any, string | import('react').JSXElementConstructor<any>> | null;
 export {};

package/dist/components/fieldText/index.d.ts

@@ -1,3 +1,4 @@
 import { FieldText } from './fieldText';
+
 export { FieldText };
 export default FieldText;